C++ EnumParseOverflowContainer类代码示例

//.........这里部分代码省略.........
          {
            return InstanceType::c3_xlarge;
          }
          else if (hashCode == c3_2xlarge_HASH)
          {
            return InstanceType::c3_2xlarge;
          }
          else if (hashCode == c3_4xlarge_HASH)
          {
            return InstanceType::c3_4xlarge;
          }
          else if (hashCode == c3_8xlarge_HASH)
          {
            return InstanceType::c3_8xlarge;
          }
          else if (hashCode == c4_large_HASH)
          {
            return InstanceType::c4_large;
          }
          else if (hashCode == c4_xlarge_HASH)
          {
            return InstanceType::c4_xlarge;
          }
          else if (hashCode == c4_2xlarge_HASH)
          {
            return InstanceType::c4_2xlarge;
          }
          else if (hashCode == c4_4xlarge_HASH)
          {
            return InstanceType::c4_4xlarge;
          }
          else if (hashCode == c4_8xlarge_HASH)
          {
            return InstanceType::c4_8xlarge;
          }
          else if (hashCode == cc1_4xlarge_HASH)
          {
            return InstanceType::cc1_4xlarge;
          }
          else if (hashCode == cc2_8xlarge_HASH)
          {
            return InstanceType::cc2_8xlarge;
          }
          else if (hashCode == g2_2xlarge_HASH)
          {
            return InstanceType::g2_2xlarge;
          }
          else if (hashCode == g2_8xlarge_HASH)
          {
            return InstanceType::g2_8xlarge;
          }
          else if (hashCode == cg1_4xlarge_HASH)
          {
            return InstanceType::cg1_4xlarge;
          }
          else if (hashCode == p2_xlarge_HASH)
          {
            return InstanceType::p2_xlarge;
          }
          else if (hashCode == p2_8xlarge_HASH)
          {
            return InstanceType::p2_8xlarge;
          }
          else if (hashCode == p2_16xlarge_HASH)
          {
            return InstanceType::p2_16xlarge;
          }
          else if (hashCode == d2_xlarge_HASH)
          {
            return InstanceType::d2_xlarge;
          }
          else if (hashCode == d2_2xlarge_HASH)
          {
            return InstanceType::d2_2xlarge;
          }
          else if (hashCode == d2_4xlarge_HASH)
          {
            return InstanceType::d2_4xlarge;
          }
          else if (hashCode == d2_8xlarge_HASH)
          {
            return InstanceType::d2_8xlarge;
          }
          else if (hashCode == f1_2xlarge_HASH)
          {
            return InstanceType::f1_2xlarge;
          }
          else if (hashCode == f1_16xlarge_HASH)
          {
            return InstanceType::f1_16xlarge;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<InstanceType>(hashCode);
          }

          return InstanceType::NOT_SET;
        }

//.........这里部分代码省略.........
          {
            return EC2InstanceType::c3_xlarge;
          }
          else if (hashCode == c3_2xlarge_HASH)
          {
            return EC2InstanceType::c3_2xlarge;
          }
          else if (hashCode == c3_4xlarge_HASH)
          {
            return EC2InstanceType::c3_4xlarge;
          }
          else if (hashCode == c3_8xlarge_HASH)
          {
            return EC2InstanceType::c3_8xlarge;
          }
          else if (hashCode == c4_large_HASH)
          {
            return EC2InstanceType::c4_large;
          }
          else if (hashCode == c4_xlarge_HASH)
          {
            return EC2InstanceType::c4_xlarge;
          }
          else if (hashCode == c4_2xlarge_HASH)
          {
            return EC2InstanceType::c4_2xlarge;
          }
          else if (hashCode == c4_4xlarge_HASH)
          {
            return EC2InstanceType::c4_4xlarge;
          }
          else if (hashCode == c4_8xlarge_HASH)
          {
            return EC2InstanceType::c4_8xlarge;
          }
          else if (hashCode == r3_large_HASH)
          {
            return EC2InstanceType::r3_large;
          }
          else if (hashCode == r3_xlarge_HASH)
          {
            return EC2InstanceType::r3_xlarge;
          }
          else if (hashCode == r3_2xlarge_HASH)
          {
            return EC2InstanceType::r3_2xlarge;
          }
          else if (hashCode == r3_4xlarge_HASH)
          {
            return EC2InstanceType::r3_4xlarge;
          }
          else if (hashCode == r3_8xlarge_HASH)
          {
            return EC2InstanceType::r3_8xlarge;
          }
          else if (hashCode == m3_medium_HASH)
          {
            return EC2InstanceType::m3_medium;
          }
          else if (hashCode == m3_large_HASH)
          {
            return EC2InstanceType::m3_large;
          }
          else if (hashCode == m3_xlarge_HASH)
          {
            return EC2InstanceType::m3_xlarge;
          }
          else if (hashCode == m3_2xlarge_HASH)
          {
            return EC2InstanceType::m3_2xlarge;
          }
          else if (hashCode == m4_large_HASH)
          {
            return EC2InstanceType::m4_large;
          }
          else if (hashCode == m4_xlarge_HASH)
          {
            return EC2InstanceType::m4_xlarge;
          }
          else if (hashCode == m4_2xlarge_HASH)
          {
            return EC2InstanceType::m4_2xlarge;
          }
          else if (hashCode == m4_4xlarge_HASH)
          {
            return EC2InstanceType::m4_4xlarge;
          }
          else if (hashCode == m4_10xlarge_HASH)
          {
            return EC2InstanceType::m4_10xlarge;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<EC2InstanceType>(hashCode);
          }

          return EC2InstanceType::NOT_SET;
        }

        ResourceType GetResourceTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == customer_gateway_HASH)
          {
            return ResourceType::customer_gateway;
          }
          else if (hashCode == dhcp_options_HASH)
          {
            return ResourceType::dhcp_options;
          }
          else if (hashCode == image_HASH)
          {
            return ResourceType::image;
          }
          else if (hashCode == instance_HASH)
          {
            return ResourceType::instance;
          }
          else if (hashCode == internet_gateway_HASH)
          {
            return ResourceType::internet_gateway;
          }
          else if (hashCode == network_acl_HASH)
          {
            return ResourceType::network_acl;
          }
          else if (hashCode == network_interface_HASH)
          {
            return ResourceType::network_interface;
          }
          else if (hashCode == reserved_instances_HASH)
          {
            return ResourceType::reserved_instances;
          }
          else if (hashCode == route_table_HASH)
          {
            return ResourceType::route_table;
          }
          else if (hashCode == snapshot_HASH)
          {
            return ResourceType::snapshot;
          }
          else if (hashCode == spot_instances_request_HASH)
          {
            return ResourceType::spot_instances_request;
          }
          else if (hashCode == subnet_HASH)
          {
            return ResourceType::subnet;
          }
          else if (hashCode == security_group_HASH)
          {
            return ResourceType::security_group;
          }
          else if (hashCode == volume_HASH)
          {
            return ResourceType::volume;
          }
          else if (hashCode == vpc_HASH)
          {
            return ResourceType::vpc;
          }
          else if (hashCode == vpn_connection_HASH)
          {
            return ResourceType::vpn_connection;
          }
          else if (hashCode == vpn_gateway_HASH)
          {
            return ResourceType::vpn_gateway;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<ResourceType>(hashCode);
          }

          return ResourceType::NOT_SET;
        }

        Aws::String GetNameForEC2InstanceType(EC2InstanceType enumValue)
        {
          switch(enumValue)
          {
          case EC2InstanceType::t2_micro:
            return "t2.micro";
          case EC2InstanceType::t2_small:
            return "t2.small";
          case EC2InstanceType::t2_medium:
            return "t2.medium";
          case EC2InstanceType::t2_large:
            return "t2.large";
          case EC2InstanceType::c3_large:
            return "c3.large";
          case EC2InstanceType::c3_xlarge:
            return "c3.xlarge";
          case EC2InstanceType::c3_2xlarge:
            return "c3.2xlarge";
          case EC2InstanceType::c3_4xlarge:
            return "c3.4xlarge";
          case EC2InstanceType::c3_8xlarge:
            return "c3.8xlarge";
          case EC2InstanceType::c4_large:
            return "c4.large";
          case EC2InstanceType::c4_xlarge:
            return "c4.xlarge";
          case EC2InstanceType::c4_2xlarge:
            return "c4.2xlarge";
          case EC2InstanceType::c4_4xlarge:
            return "c4.4xlarge";
          case EC2InstanceType::c4_8xlarge:
            return "c4.8xlarge";
          case EC2InstanceType::r3_large:
            return "r3.large";
          case EC2InstanceType::r3_xlarge:
            return "r3.xlarge";
          case EC2InstanceType::r3_2xlarge:
            return "r3.2xlarge";
          case EC2InstanceType::r3_4xlarge:
            return "r3.4xlarge";
          case EC2InstanceType::r3_8xlarge:
            return "r3.8xlarge";
          case EC2InstanceType::m3_medium:
            return "m3.medium";
          case EC2InstanceType::m3_large:
            return "m3.large";
          case EC2InstanceType::m3_xlarge:
            return "m3.xlarge";
          case EC2InstanceType::m3_2xlarge:
            return "m3.2xlarge";
          case EC2InstanceType::m4_large:
            return "m4.large";
          case EC2InstanceType::m4_xlarge:
            return "m4.xlarge";
          case EC2InstanceType::m4_2xlarge:
            return "m4.2xlarge";
          case EC2InstanceType::m4_4xlarge:
            return "m4.4xlarge";
          case EC2InstanceType::m4_10xlarge:
            return "m4.10xlarge";
          default:
            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
            if(overflowContainer)
            {
              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
            }

            return "";
          }
        }

        LifecycleState GetLifecycleStateForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == Pending_HASH)
          {
            return LifecycleState::Pending;
          }
          else if (hashCode == Pending_Wait_HASH)
          {
            return LifecycleState::Pending_Wait;
          }
          else if (hashCode == Pending_Proceed_HASH)
          {
            return LifecycleState::Pending_Proceed;
          }
          else if (hashCode == Quarantined_HASH)
          {
            return LifecycleState::Quarantined;
          }
          else if (hashCode == InService_HASH)
          {
            return LifecycleState::InService;
          }
          else if (hashCode == Terminating_HASH)
          {
            return LifecycleState::Terminating;
          }
          else if (hashCode == Terminating_Wait_HASH)
          {
            return LifecycleState::Terminating_Wait;
          }
          else if (hashCode == Terminating_Proceed_HASH)
          {
            return LifecycleState::Terminating_Proceed;
          }
          else if (hashCode == Terminated_HASH)
          {
            return LifecycleState::Terminated;
          }
          else if (hashCode == Detaching_HASH)
          {
            return LifecycleState::Detaching;
          }
          else if (hashCode == Detached_HASH)
          {
            return LifecycleState::Detached;
          }
          else if (hashCode == EnteringStandby_HASH)
          {
            return LifecycleState::EnteringStandby;
          }
          else if (hashCode == Standby_HASH)
          {
            return LifecycleState::Standby;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<LifecycleState>(hashCode);
          }

          return LifecycleState::NOT_SET;
        }

        UploadType GetUploadTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == ANDROID_APP_HASH)
          {
            return UploadType::ANDROID_APP;
          }
          else if (hashCode == IOS_APP_HASH)
          {
            return UploadType::IOS_APP;
          }
          else if (hashCode == WEB_APP_HASH)
          {
            return UploadType::WEB_APP;
          }
          else if (hashCode == EXTERNAL_DATA_HASH)
          {
            return UploadType::EXTERNAL_DATA;
          }
          else if (hashCode == APPIUM_JAVA_JUNIT_TEST_PACKAGE_HASH)
          {
            return UploadType::APPIUM_JAVA_JUNIT_TEST_PACKAGE;
          }
          else if (hashCode == APPIUM_JAVA_TESTNG_TEST_PACKAGE_HASH)
          {
            return UploadType::APPIUM_JAVA_TESTNG_TEST_PACKAGE;
          }
          else if (hashCode == APPIUM_PYTHON_TEST_PACKAGE_HASH)
          {
            return UploadType::APPIUM_PYTHON_TEST_PACKAGE;
          }
          else if (hashCode == APPIUM_WEB_JAVA_JUNIT_TEST_PACKAGE_HASH)
          {
            return UploadType::APPIUM_WEB_JAVA_JUNIT_TEST_PACKAGE;
          }
          else if (hashCode == APPIUM_WEB_JAVA_TESTNG_TEST_PACKAGE_HASH)
          {
            return UploadType::APPIUM_WEB_JAVA_TESTNG_TEST_PACKAGE;
          }
          else if (hashCode == APPIUM_WEB_PYTHON_TEST_PACKAGE_HASH)
          {
            return UploadType::APPIUM_WEB_PYTHON_TEST_PACKAGE;
          }
          else if (hashCode == CALABASH_TEST_PACKAGE_HASH)
          {
            return UploadType::CALABASH_TEST_PACKAGE;
          }
          else if (hashCode == INSTRUMENTATION_TEST_PACKAGE_HASH)
          {
            return UploadType::INSTRUMENTATION_TEST_PACKAGE;
          }
          else if (hashCode == UIAUTOMATION_TEST_PACKAGE_HASH)
          {
            return UploadType::UIAUTOMATION_TEST_PACKAGE;
          }
          else if (hashCode == UIAUTOMATOR_TEST_PACKAGE_HASH)
          {
            return UploadType::UIAUTOMATOR_TEST_PACKAGE;
          }
          else if (hashCode == XCTEST_TEST_PACKAGE_HASH)
          {
            return UploadType::XCTEST_TEST_PACKAGE;
          }
          else if (hashCode == XCTEST_UI_TEST_PACKAGE_HASH)
          {
            return UploadType::XCTEST_UI_TEST_PACKAGE;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<UploadType>(hashCode);
          }

          return UploadType::NOT_SET;
        }

//.........这里部分代码省略.........
          {
            return VoiceId::Celine;
          }
          else if (hashCode == Mathieu_HASH)
          {
            return VoiceId::Mathieu;
          }
          else if (hashCode == Dora_HASH)
          {
            return VoiceId::Dora;
          }
          else if (hashCode == Karl_HASH)
          {
            return VoiceId::Karl;
          }
          else if (hashCode == Carla_HASH)
          {
            return VoiceId::Carla;
          }
          else if (hashCode == Giorgio_HASH)
          {
            return VoiceId::Giorgio;
          }
          else if (hashCode == Mizuki_HASH)
          {
            return VoiceId::Mizuki;
          }
          else if (hashCode == Liv_HASH)
          {
            return VoiceId::Liv;
          }
          else if (hashCode == Lotte_HASH)
          {
            return VoiceId::Lotte;
          }
          else if (hashCode == Ruben_HASH)
          {
            return VoiceId::Ruben;
          }
          else if (hashCode == Ewa_HASH)
          {
            return VoiceId::Ewa;
          }
          else if (hashCode == Jacek_HASH)
          {
            return VoiceId::Jacek;
          }
          else if (hashCode == Jan_HASH)
          {
            return VoiceId::Jan;
          }
          else if (hashCode == Maja_HASH)
          {
            return VoiceId::Maja;
          }
          else if (hashCode == Ricardo_HASH)
          {
            return VoiceId::Ricardo;
          }
          else if (hashCode == Vitoria_HASH)
          {
            return VoiceId::Vitoria;
          }
          else if (hashCode == Cristiano_HASH)
          {
            return VoiceId::Cristiano;
          }
          else if (hashCode == Ines_HASH)
          {
            return VoiceId::Ines;
          }
          else if (hashCode == Carmen_HASH)
          {
            return VoiceId::Carmen;
          }
          else if (hashCode == Maxim_HASH)
          {
            return VoiceId::Maxim;
          }
          else if (hashCode == Tatyana_HASH)
          {
            return VoiceId::Tatyana;
          }
          else if (hashCode == Astrid_HASH)
          {
            return VoiceId::Astrid;
          }
          else if (hashCode == Filiz_HASH)
          {
            return VoiceId::Filiz;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<VoiceId>(hashCode);
          }

          return VoiceId::NOT_SET;
        }

        Aws::String GetNameForVoiceId(VoiceId enumValue)
        {
          switch(enumValue)
          {
          case VoiceId::Geraint:
            return "Geraint";
          case VoiceId::Gwyneth:
            return "Gwyneth";
          case VoiceId::Mads:
            return "Mads";
          case VoiceId::Naja:
            return "Naja";
          case VoiceId::Hans:
            return "Hans";
          case VoiceId::Marlene:
            return "Marlene";
          case VoiceId::Nicole:
            return "Nicole";
          case VoiceId::Russell:
            return "Russell";
          case VoiceId::Amy:
            return "Amy";
          case VoiceId::Brian:
            return "Brian";
          case VoiceId::Emma:
            return "Emma";
          case VoiceId::Raveena:
            return "Raveena";
          case VoiceId::Ivy:
            return "Ivy";
          case VoiceId::Joanna:
            return "Joanna";
          case VoiceId::Joey:
            return "Joey";
          case VoiceId::Justin:
            return "Justin";
          case VoiceId::Kendra:
            return "Kendra";
          case VoiceId::Kimberly:
            return "Kimberly";
          case VoiceId::Salli:
            return "Salli";
          case VoiceId::Conchita:
            return "Conchita";
          case VoiceId::Enrique:
            return "Enrique";
          case VoiceId::Miguel:
            return "Miguel";
          case VoiceId::Penelope:
            return "Penelope";
          case VoiceId::Chantal:
            return "Chantal";
          case VoiceId::Celine:
            return "Celine";
          case VoiceId::Mathieu:
            return "Mathieu";
          case VoiceId::Dora:
            return "Dora";
          case VoiceId::Karl:
            return "Karl";
          case VoiceId::Carla:
            return "Carla";
          case VoiceId::Giorgio:
            return "Giorgio";
          case VoiceId::Mizuki:
            return "Mizuki";
          case VoiceId::Liv:
            return "Liv";
          case VoiceId::Lotte:
            return "Lotte";
          case VoiceId::Ruben:
            return "Ruben";
          case VoiceId::Ewa:
            return "Ewa";
          case VoiceId::Jacek:
            return "Jacek";
          case VoiceId::Jan:
            return "Jan";
          case VoiceId::Maja:
            return "Maja";
          case VoiceId::Ricardo:
            return "Ricardo";
          case VoiceId::Vitoria:
            return "Vitoria";
          case VoiceId::Cristiano:
            return "Cristiano";
          case VoiceId::Ines:
            return "Ines";
          case VoiceId::Carmen:
            return "Carmen";
          case VoiceId::Maxim:
            return "Maxim";
          case VoiceId::Tatyana:
            return "Tatyana";
          case VoiceId::Astrid:
            return "Astrid";
          case VoiceId::Filiz:
            return "Filiz";
          default:
            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
//.........这里部分代码省略.........