/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #include #include #include #include using namespace Aws::Utils; namespace Aws { namespace MediaConvert { namespace Model { namespace LanguageCodeMapper { static const int ENG_HASH = HashingUtils::HashString("ENG"); static const int SPA_HASH = HashingUtils::HashString("SPA"); static const int FRA_HASH = HashingUtils::HashString("FRA"); static const int DEU_HASH = HashingUtils::HashString("DEU"); static const int GER_HASH = HashingUtils::HashString("GER"); static const int ZHO_HASH = HashingUtils::HashString("ZHO"); static const int ARA_HASH = HashingUtils::HashString("ARA"); static const int HIN_HASH = HashingUtils::HashString("HIN"); static const int JPN_HASH = HashingUtils::HashString("JPN"); static const int RUS_HASH = HashingUtils::HashString("RUS"); static const int POR_HASH = HashingUtils::HashString("POR"); static const int ITA_HASH = HashingUtils::HashString("ITA"); static const int URD_HASH = HashingUtils::HashString("URD"); static const int VIE_HASH = HashingUtils::HashString("VIE"); static const int KOR_HASH = HashingUtils::HashString("KOR"); static const int PAN_HASH = HashingUtils::HashString("PAN"); static const int ABK_HASH = HashingUtils::HashString("ABK"); static const int AAR_HASH = HashingUtils::HashString("AAR"); static const int AFR_HASH = HashingUtils::HashString("AFR"); static const int AKA_HASH = HashingUtils::HashString("AKA"); static const int SQI_HASH = HashingUtils::HashString("SQI"); static const int AMH_HASH = HashingUtils::HashString("AMH"); static const int ARG_HASH = HashingUtils::HashString("ARG"); static const int HYE_HASH = HashingUtils::HashString("HYE"); static const int ASM_HASH = HashingUtils::HashString("ASM"); static const int AVA_HASH = HashingUtils::HashString("AVA"); static const int AVE_HASH = HashingUtils::HashString("AVE"); static const int AYM_HASH = HashingUtils::HashString("AYM"); static const int AZE_HASH = HashingUtils::HashString("AZE"); static const int BAM_HASH = HashingUtils::HashString("BAM"); static const int BAK_HASH = HashingUtils::HashString("BAK"); static const int EUS_HASH = HashingUtils::HashString("EUS"); static const int BEL_HASH = HashingUtils::HashString("BEL"); static const int BEN_HASH = HashingUtils::HashString("BEN"); static const int BIH_HASH = HashingUtils::HashString("BIH"); static const int BIS_HASH = HashingUtils::HashString("BIS"); static const int BOS_HASH = HashingUtils::HashString("BOS"); static const int BRE_HASH = HashingUtils::HashString("BRE"); static const int BUL_HASH = HashingUtils::HashString("BUL"); static const int MYA_HASH = HashingUtils::HashString("MYA"); static const int CAT_HASH = HashingUtils::HashString("CAT"); static const int KHM_HASH = HashingUtils::HashString("KHM"); static const int CHA_HASH = HashingUtils::HashString("CHA"); static const int CHE_HASH = HashingUtils::HashString("CHE"); static const int NYA_HASH = HashingUtils::HashString("NYA"); static const int CHU_HASH = HashingUtils::HashString("CHU"); static const int CHV_HASH = HashingUtils::HashString("CHV"); static const int COR_HASH = HashingUtils::HashString("COR"); static const int COS_HASH = HashingUtils::HashString("COS"); static const int CRE_HASH = HashingUtils::HashString("CRE"); static const int HRV_HASH = HashingUtils::HashString("HRV"); static const int CES_HASH = HashingUtils::HashString("CES"); static const int DAN_HASH = HashingUtils::HashString("DAN"); static const int DIV_HASH = HashingUtils::HashString("DIV"); static const int NLD_HASH = HashingUtils::HashString("NLD"); static const int DZO_HASH = HashingUtils::HashString("DZO"); static const int ENM_HASH = HashingUtils::HashString("ENM"); static const int EPO_HASH = HashingUtils::HashString("EPO"); static const int EST_HASH = HashingUtils::HashString("EST"); static const int EWE_HASH = HashingUtils::HashString("EWE"); static const int FAO_HASH = HashingUtils::HashString("FAO"); static const int FIJ_HASH = HashingUtils::HashString("FIJ"); static const int FIN_HASH = HashingUtils::HashString("FIN"); static const int FRM_HASH = HashingUtils::HashString("FRM"); static const int FUL_HASH = HashingUtils::HashString("FUL"); static const int GLA_HASH = HashingUtils::HashString("GLA"); static const int GLG_HASH = HashingUtils::HashString("GLG"); static const int LUG_HASH = HashingUtils::HashString("LUG"); static const int KAT_HASH = HashingUtils::HashString("KAT"); static const int ELL_HASH = HashingUtils::HashString("ELL"); static const int GRN_HASH = HashingUtils::HashString("GRN"); static const int GUJ_HASH = HashingUtils::HashString("GUJ"); static const int HAT_HASH = HashingUtils::HashString("HAT"); static const int HAU_HASH = HashingUtils::HashString("HAU"); static const int HEB_HASH = HashingUtils::HashString("HEB"); static const int HER_HASH = HashingUtils::HashString("HER"); static const int HMO_HASH = HashingUtils::HashString("HMO"); static const int HUN_HASH = HashingUtils::HashString("HUN"); static const int ISL_HASH = HashingUtils::HashString("ISL"); static const int IDO_HASH = HashingUtils::HashString("IDO"); static const int IBO_HASH = HashingUtils::HashString("IBO"); static const int IND_HASH = HashingUtils::HashString("IND"); static const int INA_HASH = HashingUtils::HashString("INA"); static const int ILE_HASH = HashingUtils::HashString("ILE"); static const int IKU_HASH = HashingUtils::HashString("IKU"); static const int IPK_HASH = HashingUtils::HashString("IPK"); static const int GLE_HASH = HashingUtils::HashString("GLE"); static const int JAV_HASH = HashingUtils::HashString("JAV"); static const int KAL_HASH = HashingUtils::HashString("KAL"); static const int KAN_HASH = HashingUtils::HashString("KAN"); static const int KAU_HASH = HashingUtils::HashString("KAU"); static const int KAS_HASH = HashingUtils::HashString("KAS"); static const int KAZ_HASH = HashingUtils::HashString("KAZ"); static const int KIK_HASH = HashingUtils::HashString("KIK"); static const int KIN_HASH = HashingUtils::HashString("KIN"); static const int KIR_HASH = HashingUtils::HashString("KIR"); static const int KOM_HASH = HashingUtils::HashString("KOM"); static const int KON_HASH = HashingUtils::HashString("KON"); static const int KUA_HASH = HashingUtils::HashString("KUA"); static const int KUR_HASH = HashingUtils::HashString("KUR"); static const int LAO_HASH = HashingUtils::HashString("LAO"); static const int LAT_HASH = HashingUtils::HashString("LAT"); static const int LAV_HASH = HashingUtils::HashString("LAV"); static const int LIM_HASH = HashingUtils::HashString("LIM"); static const int LIN_HASH = HashingUtils::HashString("LIN"); static const int LIT_HASH = HashingUtils::HashString("LIT"); static const int LUB_HASH = HashingUtils::HashString("LUB"); static const int LTZ_HASH = HashingUtils::HashString("LTZ"); static const int MKD_HASH = HashingUtils::HashString("MKD"); static const int MLG_HASH = HashingUtils::HashString("MLG"); static const int MSA_HASH = HashingUtils::HashString("MSA"); static const int MAL_HASH = HashingUtils::HashString("MAL"); static const int MLT_HASH = HashingUtils::HashString("MLT"); static const int GLV_HASH = HashingUtils::HashString("GLV"); static const int MRI_HASH = HashingUtils::HashString("MRI"); static const int MAR_HASH = HashingUtils::HashString("MAR"); static const int MAH_HASH = HashingUtils::HashString("MAH"); static const int MON_HASH = HashingUtils::HashString("MON"); static const int NAU_HASH = HashingUtils::HashString("NAU"); static const int NAV_HASH = HashingUtils::HashString("NAV"); static const int NDE_HASH = HashingUtils::HashString("NDE"); static const int NBL_HASH = HashingUtils::HashString("NBL"); static const int NDO_HASH = HashingUtils::HashString("NDO"); static const int NEP_HASH = HashingUtils::HashString("NEP"); static const int SME_HASH = HashingUtils::HashString("SME"); static const int NOR_HASH = HashingUtils::HashString("NOR"); static const int NOB_HASH = HashingUtils::HashString("NOB"); static const int NNO_HASH = HashingUtils::HashString("NNO"); static const int OCI_HASH = HashingUtils::HashString("OCI"); static const int OJI_HASH = HashingUtils::HashString("OJI"); static const int ORI_HASH = HashingUtils::HashString("ORI"); static const int ORM_HASH = HashingUtils::HashString("ORM"); static const int OSS_HASH = HashingUtils::HashString("OSS"); static const int PLI_HASH = HashingUtils::HashString("PLI"); static const int FAS_HASH = HashingUtils::HashString("FAS"); static const int POL_HASH = HashingUtils::HashString("POL"); static const int PUS_HASH = HashingUtils::HashString("PUS"); static const int QUE_HASH = HashingUtils::HashString("QUE"); static const int QAA_HASH = HashingUtils::HashString("QAA"); static const int RON_HASH = HashingUtils::HashString("RON"); static const int ROH_HASH = HashingUtils::HashString("ROH"); static const int RUN_HASH = HashingUtils::HashString("RUN"); static const int SMO_HASH = HashingUtils::HashString("SMO"); static const int SAG_HASH = HashingUtils::HashString("SAG"); static const int SAN_HASH = HashingUtils::HashString("SAN"); static const int SRD_HASH = HashingUtils::HashString("SRD"); static const int SRB_HASH = HashingUtils::HashString("SRB"); static const int SNA_HASH = HashingUtils::HashString("SNA"); static const int III_HASH = HashingUtils::HashString("III"); static const int SND_HASH = HashingUtils::HashString("SND"); static const int SIN_HASH = HashingUtils::HashString("SIN"); static const int SLK_HASH = HashingUtils::HashString("SLK"); static const int SLV_HASH = HashingUtils::HashString("SLV"); static const int SOM_HASH = HashingUtils::HashString("SOM"); static const int SOT_HASH = HashingUtils::HashString("SOT"); static const int SUN_HASH = HashingUtils::HashString("SUN"); static const int SWA_HASH = HashingUtils::HashString("SWA"); static const int SSW_HASH = HashingUtils::HashString("SSW"); static const int SWE_HASH = HashingUtils::HashString("SWE"); static const int TGL_HASH = HashingUtils::HashString("TGL"); static const int TAH_HASH = HashingUtils::HashString("TAH"); static const int TGK_HASH = HashingUtils::HashString("TGK"); static const int TAM_HASH = HashingUtils::HashString("TAM"); static const int TAT_HASH = HashingUtils::HashString("TAT"); static const int TEL_HASH = HashingUtils::HashString("TEL"); static const int THA_HASH = HashingUtils::HashString("THA"); static const int BOD_HASH = HashingUtils::HashString("BOD"); static const int TIR_HASH = HashingUtils::HashString("TIR"); static const int TON_HASH = HashingUtils::HashString("TON"); static const int TSO_HASH = HashingUtils::HashString("TSO"); static const int TSN_HASH = HashingUtils::HashString("TSN"); static const int TUR_HASH = HashingUtils::HashString("TUR"); static const int TUK_HASH = HashingUtils::HashString("TUK"); static const int TWI_HASH = HashingUtils::HashString("TWI"); static const int UIG_HASH = HashingUtils::HashString("UIG"); static const int UKR_HASH = HashingUtils::HashString("UKR"); static const int UZB_HASH = HashingUtils::HashString("UZB"); static const int VEN_HASH = HashingUtils::HashString("VEN"); static const int VOL_HASH = HashingUtils::HashString("VOL"); static const int WLN_HASH = HashingUtils::HashString("WLN"); static const int CYM_HASH = HashingUtils::HashString("CYM"); static const int FRY_HASH = HashingUtils::HashString("FRY"); static const int WOL_HASH = HashingUtils::HashString("WOL"); static const int XHO_HASH = HashingUtils::HashString("XHO"); static const int YID_HASH = HashingUtils::HashString("YID"); static const int YOR_HASH = HashingUtils::HashString("YOR"); static const int ZHA_HASH = HashingUtils::HashString("ZHA"); static const int ZUL_HASH = HashingUtils::HashString("ZUL"); static const int ORJ_HASH = HashingUtils::HashString("ORJ"); static const int QPC_HASH = HashingUtils::HashString("QPC"); static const int TNG_HASH = HashingUtils::HashString("TNG"); static const int SRP_HASH = HashingUtils::HashString("SRP"); /* The if-else chains in this file are converted into a jump table by the compiler, which allows constant time lookup. The chain has been broken into helper functions because MSVC has a maximum of 122 chained if-else blocks. */ static bool GetEnumForNameHelper0(int hashCode, LanguageCode& enumValue) { if (hashCode == ENG_HASH) { enumValue = LanguageCode::ENG; return true; } else if (hashCode == SPA_HASH) { enumValue = LanguageCode::SPA; return true; } else if (hashCode == FRA_HASH) { enumValue = LanguageCode::FRA; return true; } else if (hashCode == DEU_HASH) { enumValue = LanguageCode::DEU; return true; } else if (hashCode == GER_HASH) { enumValue = LanguageCode::GER; return true; } else if (hashCode == ZHO_HASH) { enumValue = LanguageCode::ZHO; return true; } else if (hashCode == ARA_HASH) { enumValue = LanguageCode::ARA; return true; } else if (hashCode == HIN_HASH) { enumValue = LanguageCode::HIN; return true; } else if (hashCode == JPN_HASH) { enumValue = LanguageCode::JPN; return true; } else if (hashCode == RUS_HASH) { enumValue = LanguageCode::RUS; return true; } else if (hashCode == POR_HASH) { enumValue = LanguageCode::POR; return true; } else if (hashCode == ITA_HASH) { enumValue = LanguageCode::ITA; return true; } else if (hashCode == URD_HASH) { enumValue = LanguageCode::URD; return true; } else if (hashCode == VIE_HASH) { enumValue = LanguageCode::VIE; return true; } else if (hashCode == KOR_HASH) { enumValue = LanguageCode::KOR; return true; } else if (hashCode == PAN_HASH) { enumValue = LanguageCode::PAN; return true; } else if (hashCode == ABK_HASH) { enumValue = LanguageCode::ABK; return true; } else if (hashCode == AAR_HASH) { enumValue = LanguageCode::AAR; return true; } else if (hashCode == AFR_HASH) { enumValue = LanguageCode::AFR; return true; } else if (hashCode == AKA_HASH) { enumValue = LanguageCode::AKA; return true; } else if (hashCode == SQI_HASH) { enumValue = LanguageCode::SQI; return true; } else if (hashCode == AMH_HASH) { enumValue = LanguageCode::AMH; return true; } else if (hashCode == ARG_HASH) { enumValue = LanguageCode::ARG; return true; } else if (hashCode == HYE_HASH) { enumValue = LanguageCode::HYE; return true; } else if (hashCode == ASM_HASH) { enumValue = LanguageCode::ASM; return true; } else if (hashCode == AVA_HASH) { enumValue = LanguageCode::AVA; return true; } else if (hashCode == AVE_HASH) { enumValue = LanguageCode::AVE; return true; } else if (hashCode == AYM_HASH) { enumValue = LanguageCode::AYM; return true; } else if (hashCode == AZE_HASH) { enumValue = LanguageCode::AZE; return true; } else if (hashCode == BAM_HASH) { enumValue = LanguageCode::BAM; return true; } else if (hashCode == BAK_HASH) { enumValue = LanguageCode::BAK; return true; } else if (hashCode == EUS_HASH) { enumValue = LanguageCode::EUS; return true; } else if (hashCode == BEL_HASH) { enumValue = LanguageCode::BEL; return true; } else if (hashCode == BEN_HASH) { enumValue = LanguageCode::BEN; return true; } else if (hashCode == BIH_HASH) { enumValue = LanguageCode::BIH; return true; } else if (hashCode == BIS_HASH) { enumValue = LanguageCode::BIS; return true; } else if (hashCode == BOS_HASH) { enumValue = LanguageCode::BOS; return true; } else if (hashCode == BRE_HASH) { enumValue = LanguageCode::BRE; return true; } else if (hashCode == BUL_HASH) { enumValue = LanguageCode::BUL; return true; } else if (hashCode == MYA_HASH) { enumValue = LanguageCode::MYA; return true; } else if (hashCode == CAT_HASH) { enumValue = LanguageCode::CAT; return true; } else if (hashCode == KHM_HASH) { enumValue = LanguageCode::KHM; return true; } else if (hashCode == CHA_HASH) { enumValue = LanguageCode::CHA; return true; } else if (hashCode == CHE_HASH) { enumValue = LanguageCode::CHE; return true; } else if (hashCode == NYA_HASH) { enumValue = LanguageCode::NYA; return true; } else if (hashCode == CHU_HASH) { enumValue = LanguageCode::CHU; return true; } else if (hashCode == CHV_HASH) { enumValue = LanguageCode::CHV; return true; } else if (hashCode == COR_HASH) { enumValue = LanguageCode::COR; return true; } else if (hashCode == COS_HASH) { enumValue = LanguageCode::COS; return true; } else if (hashCode == CRE_HASH) { enumValue = LanguageCode::CRE; return true; } else if (hashCode == HRV_HASH) { enumValue = LanguageCode::HRV; return true; } else if (hashCode == CES_HASH) { enumValue = LanguageCode::CES; return true; } else if (hashCode == DAN_HASH) { enumValue = LanguageCode::DAN; return true; } else if (hashCode == DIV_HASH) { enumValue = LanguageCode::DIV; return true; } else if (hashCode == NLD_HASH) { enumValue = LanguageCode::NLD; return true; } else if (hashCode == DZO_HASH) { enumValue = LanguageCode::DZO; return true; } else if (hashCode == ENM_HASH) { enumValue = LanguageCode::ENM; return true; } else if (hashCode == EPO_HASH) { enumValue = LanguageCode::EPO; return true; } else if (hashCode == EST_HASH) { enumValue = LanguageCode::EST; return true; } else if (hashCode == EWE_HASH) { enumValue = LanguageCode::EWE; return true; } else if (hashCode == FAO_HASH) { enumValue = LanguageCode::FAO; return true; } else if (hashCode == FIJ_HASH) { enumValue = LanguageCode::FIJ; return true; } else if (hashCode == FIN_HASH) { enumValue = LanguageCode::FIN; return true; } else if (hashCode == FRM_HASH) { enumValue = LanguageCode::FRM; return true; } else if (hashCode == FUL_HASH) { enumValue = LanguageCode::FUL; return true; } else if (hashCode == GLA_HASH) { enumValue = LanguageCode::GLA; return true; } else if (hashCode == GLG_HASH) { enumValue = LanguageCode::GLG; return true; } else if (hashCode == LUG_HASH) { enumValue = LanguageCode::LUG; return true; } else if (hashCode == KAT_HASH) { enumValue = LanguageCode::KAT; return true; } else if (hashCode == ELL_HASH) { enumValue = LanguageCode::ELL; return true; } else if (hashCode == GRN_HASH) { enumValue = LanguageCode::GRN; return true; } else if (hashCode == GUJ_HASH) { enumValue = LanguageCode::GUJ; return true; } else if (hashCode == HAT_HASH) { enumValue = LanguageCode::HAT; return true; } else if (hashCode == HAU_HASH) { enumValue = LanguageCode::HAU; return true; } else if (hashCode == HEB_HASH) { enumValue = LanguageCode::HEB; return true; } else if (hashCode == HER_HASH) { enumValue = LanguageCode::HER; return true; } else if (hashCode == HMO_HASH) { enumValue = LanguageCode::HMO; return true; } else if (hashCode == HUN_HASH) { enumValue = LanguageCode::HUN; return true; } else if (hashCode == ISL_HASH) { enumValue = LanguageCode::ISL; return true; } else if (hashCode == IDO_HASH) { enumValue = LanguageCode::IDO; return true; } else if (hashCode == IBO_HASH) { enumValue = LanguageCode::IBO; return true; } else if (hashCode == IND_HASH) { enumValue = LanguageCode::IND; return true; } else if (hashCode == INA_HASH) { enumValue = LanguageCode::INA; return true; } else if (hashCode == ILE_HASH) { enumValue = LanguageCode::ILE; return true; } else if (hashCode == IKU_HASH) { enumValue = LanguageCode::IKU; return true; } else if (hashCode == IPK_HASH) { enumValue = LanguageCode::IPK; return true; } else if (hashCode == GLE_HASH) { enumValue = LanguageCode::GLE; return true; } else if (hashCode == JAV_HASH) { enumValue = LanguageCode::JAV; return true; } else if (hashCode == KAL_HASH) { enumValue = LanguageCode::KAL; return true; } else if (hashCode == KAN_HASH) { enumValue = LanguageCode::KAN; return true; } else if (hashCode == KAU_HASH) { enumValue = LanguageCode::KAU; return true; } else if (hashCode == KAS_HASH) { enumValue = LanguageCode::KAS; return true; } else if (hashCode == KAZ_HASH) { enumValue = LanguageCode::KAZ; return true; } else if (hashCode == KIK_HASH) { enumValue = LanguageCode::KIK; return true; } else if (hashCode == KIN_HASH) { enumValue = LanguageCode::KIN; return true; } else if (hashCode == KIR_HASH) { enumValue = LanguageCode::KIR; return true; } else if (hashCode == KOM_HASH) { enumValue = LanguageCode::KOM; return true; } else if (hashCode == KON_HASH) { enumValue = LanguageCode::KON; return true; } else if (hashCode == KUA_HASH) { enumValue = LanguageCode::KUA; return true; } else if (hashCode == KUR_HASH) { enumValue = LanguageCode::KUR; return true; } else if (hashCode == LAO_HASH) { enumValue = LanguageCode::LAO; return true; } else if (hashCode == LAT_HASH) { enumValue = LanguageCode::LAT; return true; } else if (hashCode == LAV_HASH) { enumValue = LanguageCode::LAV; return true; } else if (hashCode == LIM_HASH) { enumValue = LanguageCode::LIM; return true; } else if (hashCode == LIN_HASH) { enumValue = LanguageCode::LIN; return true; } else if (hashCode == LIT_HASH) { enumValue = LanguageCode::LIT; return true; } else if (hashCode == LUB_HASH) { enumValue = LanguageCode::LUB; return true; } else if (hashCode == LTZ_HASH) { enumValue = LanguageCode::LTZ; return true; } else if (hashCode == MKD_HASH) { enumValue = LanguageCode::MKD; return true; } else if (hashCode == MLG_HASH) { enumValue = LanguageCode::MLG; return true; } else if (hashCode == MSA_HASH) { enumValue = LanguageCode::MSA; return true; } else if (hashCode == MAL_HASH) { enumValue = LanguageCode::MAL; return true; } else if (hashCode == MLT_HASH) { enumValue = LanguageCode::MLT; return true; } else if (hashCode == GLV_HASH) { enumValue = LanguageCode::GLV; return true; } else if (hashCode == MRI_HASH) { enumValue = LanguageCode::MRI; return true; } else if (hashCode == MAR_HASH) { enumValue = LanguageCode::MAR; return true; } else if (hashCode == MAH_HASH) { enumValue = LanguageCode::MAH; return true; } else if (hashCode == MON_HASH) { enumValue = LanguageCode::MON; return true; } else if (hashCode == NAU_HASH) { enumValue = LanguageCode::NAU; return true; } else if (hashCode == NAV_HASH) { enumValue = LanguageCode::NAV; return true; } else if (hashCode == NDE_HASH) { enumValue = LanguageCode::NDE; return true; } else if (hashCode == NBL_HASH) { enumValue = LanguageCode::NBL; return true; } return false; } static bool GetEnumForNameHelper1(int hashCode, LanguageCode& enumValue) { if (hashCode == NDO_HASH) { enumValue = LanguageCode::NDO; return true; } else if (hashCode == NEP_HASH) { enumValue = LanguageCode::NEP; return true; } else if (hashCode == SME_HASH) { enumValue = LanguageCode::SME; return true; } else if (hashCode == NOR_HASH) { enumValue = LanguageCode::NOR; return true; } else if (hashCode == NOB_HASH) { enumValue = LanguageCode::NOB; return true; } else if (hashCode == NNO_HASH) { enumValue = LanguageCode::NNO; return true; } else if (hashCode == OCI_HASH) { enumValue = LanguageCode::OCI; return true; } else if (hashCode == OJI_HASH) { enumValue = LanguageCode::OJI; return true; } else if (hashCode == ORI_HASH) { enumValue = LanguageCode::ORI; return true; } else if (hashCode == ORM_HASH) { enumValue = LanguageCode::ORM; return true; } else if (hashCode == OSS_HASH) { enumValue = LanguageCode::OSS; return true; } else if (hashCode == PLI_HASH) { enumValue = LanguageCode::PLI; return true; } else if (hashCode == FAS_HASH) { enumValue = LanguageCode::FAS; return true; } else if (hashCode == POL_HASH) { enumValue = LanguageCode::POL; return true; } else if (hashCode == PUS_HASH) { enumValue = LanguageCode::PUS; return true; } else if (hashCode == QUE_HASH) { enumValue = LanguageCode::QUE; return true; } else if (hashCode == QAA_HASH) { enumValue = LanguageCode::QAA; return true; } else if (hashCode == RON_HASH) { enumValue = LanguageCode::RON; return true; } else if (hashCode == ROH_HASH) { enumValue = LanguageCode::ROH; return true; } else if (hashCode == RUN_HASH) { enumValue = LanguageCode::RUN; return true; } else if (hashCode == SMO_HASH) { enumValue = LanguageCode::SMO; return true; } else if (hashCode == SAG_HASH) { enumValue = LanguageCode::SAG; return true; } else if (hashCode == SAN_HASH) { enumValue = LanguageCode::SAN; return true; } else if (hashCode == SRD_HASH) { enumValue = LanguageCode::SRD; return true; } else if (hashCode == SRB_HASH) { enumValue = LanguageCode::SRB; return true; } else if (hashCode == SNA_HASH) { enumValue = LanguageCode::SNA; return true; } else if (hashCode == III_HASH) { enumValue = LanguageCode::III; return true; } else if (hashCode == SND_HASH) { enumValue = LanguageCode::SND; return true; } else if (hashCode == SIN_HASH) { enumValue = LanguageCode::SIN; return true; } else if (hashCode == SLK_HASH) { enumValue = LanguageCode::SLK; return true; } else if (hashCode == SLV_HASH) { enumValue = LanguageCode::SLV; return true; } else if (hashCode == SOM_HASH) { enumValue = LanguageCode::SOM; return true; } else if (hashCode == SOT_HASH) { enumValue = LanguageCode::SOT; return true; } else if (hashCode == SUN_HASH) { enumValue = LanguageCode::SUN; return true; } else if (hashCode == SWA_HASH) { enumValue = LanguageCode::SWA; return true; } else if (hashCode == SSW_HASH) { enumValue = LanguageCode::SSW; return true; } else if (hashCode == SWE_HASH) { enumValue = LanguageCode::SWE; return true; } else if (hashCode == TGL_HASH) { enumValue = LanguageCode::TGL; return true; } else if (hashCode == TAH_HASH) { enumValue = LanguageCode::TAH; return true; } else if (hashCode == TGK_HASH) { enumValue = LanguageCode::TGK; return true; } else if (hashCode == TAM_HASH) { enumValue = LanguageCode::TAM; return true; } else if (hashCode == TAT_HASH) { enumValue = LanguageCode::TAT; return true; } else if (hashCode == TEL_HASH) { enumValue = LanguageCode::TEL; return true; } else if (hashCode == THA_HASH) { enumValue = LanguageCode::THA; return true; } else if (hashCode == BOD_HASH) { enumValue = LanguageCode::BOD; return true; } else if (hashCode == TIR_HASH) { enumValue = LanguageCode::TIR; return true; } else if (hashCode == TON_HASH) { enumValue = LanguageCode::TON; return true; } else if (hashCode == TSO_HASH) { enumValue = LanguageCode::TSO; return true; } else if (hashCode == TSN_HASH) { enumValue = LanguageCode::TSN; return true; } else if (hashCode == TUR_HASH) { enumValue = LanguageCode::TUR; return true; } else if (hashCode == TUK_HASH) { enumValue = LanguageCode::TUK; return true; } else if (hashCode == TWI_HASH) { enumValue = LanguageCode::TWI; return true; } else if (hashCode == UIG_HASH) { enumValue = LanguageCode::UIG; return true; } else if (hashCode == UKR_HASH) { enumValue = LanguageCode::UKR; return true; } else if (hashCode == UZB_HASH) { enumValue = LanguageCode::UZB; return true; } else if (hashCode == VEN_HASH) { enumValue = LanguageCode::VEN; return true; } else if (hashCode == VOL_HASH) { enumValue = LanguageCode::VOL; return true; } else if (hashCode == WLN_HASH) { enumValue = LanguageCode::WLN; return true; } else if (hashCode == CYM_HASH) { enumValue = LanguageCode::CYM; return true; } else if (hashCode == FRY_HASH) { enumValue = LanguageCode::FRY; return true; } else if (hashCode == WOL_HASH) { enumValue = LanguageCode::WOL; return true; } else if (hashCode == XHO_HASH) { enumValue = LanguageCode::XHO; return true; } else if (hashCode == YID_HASH) { enumValue = LanguageCode::YID; return true; } else if (hashCode == YOR_HASH) { enumValue = LanguageCode::YOR; return true; } else if (hashCode == ZHA_HASH) { enumValue = LanguageCode::ZHA; return true; } else if (hashCode == ZUL_HASH) { enumValue = LanguageCode::ZUL; return true; } else if (hashCode == ORJ_HASH) { enumValue = LanguageCode::ORJ; return true; } else if (hashCode == QPC_HASH) { enumValue = LanguageCode::QPC; return true; } else if (hashCode == TNG_HASH) { enumValue = LanguageCode::TNG; return true; } else if (hashCode == SRP_HASH) { enumValue = LanguageCode::SRP; return true; } return false; } static bool GetNameForEnumHelper0(LanguageCode enumValue, Aws::String& value) { switch(enumValue) { case LanguageCode::ENG: value = "ENG"; return true; case LanguageCode::SPA: value = "SPA"; return true; case LanguageCode::FRA: value = "FRA"; return true; case LanguageCode::DEU: value = "DEU"; return true; case LanguageCode::GER: value = "GER"; return true; case LanguageCode::ZHO: value = "ZHO"; return true; case LanguageCode::ARA: value = "ARA"; return true; case LanguageCode::HIN: value = "HIN"; return true; case LanguageCode::JPN: value = "JPN"; return true; case LanguageCode::RUS: value = "RUS"; return true; case LanguageCode::POR: value = "POR"; return true; case LanguageCode::ITA: value = "ITA"; return true; case LanguageCode::URD: value = "URD"; return true; case LanguageCode::VIE: value = "VIE"; return true; case LanguageCode::KOR: value = "KOR"; return true; case LanguageCode::PAN: value = "PAN"; return true; case LanguageCode::ABK: value = "ABK"; return true; case LanguageCode::AAR: value = "AAR"; return true; case LanguageCode::AFR: value = "AFR"; return true; case LanguageCode::AKA: value = "AKA"; return true; case LanguageCode::SQI: value = "SQI"; return true; case LanguageCode::AMH: value = "AMH"; return true; case LanguageCode::ARG: value = "ARG"; return true; case LanguageCode::HYE: value = "HYE"; return true; case LanguageCode::ASM: value = "ASM"; return true; case LanguageCode::AVA: value = "AVA"; return true; case LanguageCode::AVE: value = "AVE"; return true; case LanguageCode::AYM: value = "AYM"; return true; case LanguageCode::AZE: value = "AZE"; return true; case LanguageCode::BAM: value = "BAM"; return true; case LanguageCode::BAK: value = "BAK"; return true; case LanguageCode::EUS: value = "EUS"; return true; case LanguageCode::BEL: value = "BEL"; return true; case LanguageCode::BEN: value = "BEN"; return true; case LanguageCode::BIH: value = "BIH"; return true; case LanguageCode::BIS: value = "BIS"; return true; case LanguageCode::BOS: value = "BOS"; return true; case LanguageCode::BRE: value = "BRE"; return true; case LanguageCode::BUL: value = "BUL"; return true; case LanguageCode::MYA: value = "MYA"; return true; case LanguageCode::CAT: value = "CAT"; return true; case LanguageCode::KHM: value = "KHM"; return true; case LanguageCode::CHA: value = "CHA"; return true; case LanguageCode::CHE: value = "CHE"; return true; case LanguageCode::NYA: value = "NYA"; return true; case LanguageCode::CHU: value = "CHU"; return true; case LanguageCode::CHV: value = "CHV"; return true; case LanguageCode::COR: value = "COR"; return true; case LanguageCode::COS: value = "COS"; return true; case LanguageCode::CRE: value = "CRE"; return true; case LanguageCode::HRV: value = "HRV"; return true; case LanguageCode::CES: value = "CES"; return true; case LanguageCode::DAN: value = "DAN"; return true; case LanguageCode::DIV: value = "DIV"; return true; case LanguageCode::NLD: value = "NLD"; return true; case LanguageCode::DZO: value = "DZO"; return true; case LanguageCode::ENM: value = "ENM"; return true; case LanguageCode::EPO: value = "EPO"; return true; case LanguageCode::EST: value = "EST"; return true; case LanguageCode::EWE: value = "EWE"; return true; case LanguageCode::FAO: value = "FAO"; return true; case LanguageCode::FIJ: value = "FIJ"; return true; case LanguageCode::FIN: value = "FIN"; return true; case LanguageCode::FRM: value = "FRM"; return true; case LanguageCode::FUL: value = "FUL"; return true; case LanguageCode::GLA: value = "GLA"; return true; case LanguageCode::GLG: value = "GLG"; return true; case LanguageCode::LUG: value = "LUG"; return true; case LanguageCode::KAT: value = "KAT"; return true; case LanguageCode::ELL: value = "ELL"; return true; case LanguageCode::GRN: value = "GRN"; return true; case LanguageCode::GUJ: value = "GUJ"; return true; case LanguageCode::HAT: value = "HAT"; return true; case LanguageCode::HAU: value = "HAU"; return true; case LanguageCode::HEB: value = "HEB"; return true; case LanguageCode::HER: value = "HER"; return true; case LanguageCode::HMO: value = "HMO"; return true; case LanguageCode::HUN: value = "HUN"; return true; case LanguageCode::ISL: value = "ISL"; return true; case LanguageCode::IDO: value = "IDO"; return true; case LanguageCode::IBO: value = "IBO"; return true; case LanguageCode::IND: value = "IND"; return true; case LanguageCode::INA: value = "INA"; return true; case LanguageCode::ILE: value = "ILE"; return true; case LanguageCode::IKU: value = "IKU"; return true; case LanguageCode::IPK: value = "IPK"; return true; case LanguageCode::GLE: value = "GLE"; return true; case LanguageCode::JAV: value = "JAV"; return true; case LanguageCode::KAL: value = "KAL"; return true; case LanguageCode::KAN: value = "KAN"; return true; case LanguageCode::KAU: value = "KAU"; return true; case LanguageCode::KAS: value = "KAS"; return true; case LanguageCode::KAZ: value = "KAZ"; return true; case LanguageCode::KIK: value = "KIK"; return true; case LanguageCode::KIN: value = "KIN"; return true; case LanguageCode::KIR: value = "KIR"; return true; case LanguageCode::KOM: value = "KOM"; return true; case LanguageCode::KON: value = "KON"; return true; case LanguageCode::KUA: value = "KUA"; return true; case LanguageCode::KUR: value = "KUR"; return true; case LanguageCode::LAO: value = "LAO"; return true; case LanguageCode::LAT: value = "LAT"; return true; case LanguageCode::LAV: value = "LAV"; return true; case LanguageCode::LIM: value = "LIM"; return true; case LanguageCode::LIN: value = "LIN"; return true; case LanguageCode::LIT: value = "LIT"; return true; case LanguageCode::LUB: value = "LUB"; return true; case LanguageCode::LTZ: value = "LTZ"; return true; case LanguageCode::MKD: value = "MKD"; return true; case LanguageCode::MLG: value = "MLG"; return true; case LanguageCode::MSA: value = "MSA"; return true; case LanguageCode::MAL: value = "MAL"; return true; case LanguageCode::MLT: value = "MLT"; return true; case LanguageCode::GLV: value = "GLV"; return true; case LanguageCode::MRI: value = "MRI"; return true; case LanguageCode::MAR: value = "MAR"; return true; case LanguageCode::MAH: value = "MAH"; return true; case LanguageCode::MON: value = "MON"; return true; case LanguageCode::NAU: value = "NAU"; return true; case LanguageCode::NAV: value = "NAV"; return true; case LanguageCode::NDE: value = "NDE"; return true; case LanguageCode::NBL: value = "NBL"; return true; default: return false; } } static bool GetNameForEnumHelper1(LanguageCode enumValue, Aws::String& value) { switch(enumValue) { case LanguageCode::NDO: value = "NDO"; return true; case LanguageCode::NEP: value = "NEP"; return true; case LanguageCode::SME: value = "SME"; return true; case LanguageCode::NOR: value = "NOR"; return true; case LanguageCode::NOB: value = "NOB"; return true; case LanguageCode::NNO: value = "NNO"; return true; case LanguageCode::OCI: value = "OCI"; return true; case LanguageCode::OJI: value = "OJI"; return true; case LanguageCode::ORI: value = "ORI"; return true; case LanguageCode::ORM: value = "ORM"; return true; case LanguageCode::OSS: value = "OSS"; return true; case LanguageCode::PLI: value = "PLI"; return true; case LanguageCode::FAS: value = "FAS"; return true; case LanguageCode::POL: value = "POL"; return true; case LanguageCode::PUS: value = "PUS"; return true; case LanguageCode::QUE: value = "QUE"; return true; case LanguageCode::QAA: value = "QAA"; return true; case LanguageCode::RON: value = "RON"; return true; case LanguageCode::ROH: value = "ROH"; return true; case LanguageCode::RUN: value = "RUN"; return true; case LanguageCode::SMO: value = "SMO"; return true; case LanguageCode::SAG: value = "SAG"; return true; case LanguageCode::SAN: value = "SAN"; return true; case LanguageCode::SRD: value = "SRD"; return true; case LanguageCode::SRB: value = "SRB"; return true; case LanguageCode::SNA: value = "SNA"; return true; case LanguageCode::III: value = "III"; return true; case LanguageCode::SND: value = "SND"; return true; case LanguageCode::SIN: value = "SIN"; return true; case LanguageCode::SLK: value = "SLK"; return true; case LanguageCode::SLV: value = "SLV"; return true; case LanguageCode::SOM: value = "SOM"; return true; case LanguageCode::SOT: value = "SOT"; return true; case LanguageCode::SUN: value = "SUN"; return true; case LanguageCode::SWA: value = "SWA"; return true; case LanguageCode::SSW: value = "SSW"; return true; case LanguageCode::SWE: value = "SWE"; return true; case LanguageCode::TGL: value = "TGL"; return true; case LanguageCode::TAH: value = "TAH"; return true; case LanguageCode::TGK: value = "TGK"; return true; case LanguageCode::TAM: value = "TAM"; return true; case LanguageCode::TAT: value = "TAT"; return true; case LanguageCode::TEL: value = "TEL"; return true; case LanguageCode::THA: value = "THA"; return true; case LanguageCode::BOD: value = "BOD"; return true; case LanguageCode::TIR: value = "TIR"; return true; case LanguageCode::TON: value = "TON"; return true; case LanguageCode::TSO: value = "TSO"; return true; case LanguageCode::TSN: value = "TSN"; return true; case LanguageCode::TUR: value = "TUR"; return true; case LanguageCode::TUK: value = "TUK"; return true; case LanguageCode::TWI: value = "TWI"; return true; case LanguageCode::UIG: value = "UIG"; return true; case LanguageCode::UKR: value = "UKR"; return true; case LanguageCode::UZB: value = "UZB"; return true; case LanguageCode::VEN: value = "VEN"; return true; case LanguageCode::VOL: value = "VOL"; return true; case LanguageCode::WLN: value = "WLN"; return true; case LanguageCode::CYM: value = "CYM"; return true; case LanguageCode::FRY: value = "FRY"; return true; case LanguageCode::WOL: value = "WOL"; return true; case LanguageCode::XHO: value = "XHO"; return true; case LanguageCode::YID: value = "YID"; return true; case LanguageCode::YOR: value = "YOR"; return true; case LanguageCode::ZHA: value = "ZHA"; return true; case LanguageCode::ZUL: value = "ZUL"; return true; case LanguageCode::ORJ: value = "ORJ"; return true; case LanguageCode::QPC: value = "QPC"; return true; case LanguageCode::TNG: value = "TNG"; return true; case LanguageCode::SRP: value = "SRP"; return true; default: return false; } } LanguageCode GetLanguageCodeForName(const Aws::String& name) { int hashCode = HashingUtils::HashString(name.c_str()); LanguageCode enumValue; if (GetEnumForNameHelper0(hashCode, enumValue)) { return enumValue; } else if (GetEnumForNameHelper1(hashCode, enumValue)) { return enumValue; } EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer(); if(overflowContainer) { overflowContainer->StoreOverflow(hashCode, name); return static_cast(hashCode); } return LanguageCode::NOT_SET; } Aws::String GetNameForLanguageCode(LanguageCode enumValue) { Aws::String value; if (GetNameForEnumHelper0(enumValue, value)) { return value; } else if (GetNameForEnumHelper1(enumValue, value)) { return value; } EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer(); if(overflowContainer) { return overflowContainer->RetrieveOverflow(static_cast(enumValue)); } return {}; } } // namespace LanguageCodeMapper } // namespace Model } // namespace MediaConvert } // namespace Aws