1 /**
2  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3  * SPDX-License-Identifier: Apache-2.0.
4  */
5 
6 #include <aws/codebuild/model/LanguageType.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 CodeBuild
17   {
18     namespace Model
19     {
20       namespace LanguageTypeMapper
21       {
22 
23         static const int JAVA_HASH = HashingUtils::HashString("JAVA");
24         static const int PYTHON_HASH = HashingUtils::HashString("PYTHON");
25         static const int NODE_JS_HASH = HashingUtils::HashString("NODE_JS");
26         static const int RUBY_HASH = HashingUtils::HashString("RUBY");
27         static const int GOLANG_HASH = HashingUtils::HashString("GOLANG");
28         static const int DOCKER_HASH = HashingUtils::HashString("DOCKER");
29         static const int ANDROID__HASH = HashingUtils::HashString("ANDROID");
30         static const int DOTNET_HASH = HashingUtils::HashString("DOTNET");
31         static const int BASE_HASH = HashingUtils::HashString("BASE");
32         static const int PHP_HASH = HashingUtils::HashString("PHP");
33 
34 
GetLanguageTypeForName(const Aws::String & name)35         LanguageType GetLanguageTypeForName(const Aws::String& name)
36         {
37           int hashCode = HashingUtils::HashString(name.c_str());
38           if (hashCode == JAVA_HASH)
39           {
40             return LanguageType::JAVA;
41           }
42           else if (hashCode == PYTHON_HASH)
43           {
44             return LanguageType::PYTHON;
45           }
46           else if (hashCode == NODE_JS_HASH)
47           {
48             return LanguageType::NODE_JS;
49           }
50           else if (hashCode == RUBY_HASH)
51           {
52             return LanguageType::RUBY;
53           }
54           else if (hashCode == GOLANG_HASH)
55           {
56             return LanguageType::GOLANG;
57           }
58           else if (hashCode == DOCKER_HASH)
59           {
60             return LanguageType::DOCKER;
61           }
62           else if (hashCode == ANDROID__HASH)
63           {
64             return LanguageType::ANDROID_;
65           }
66           else if (hashCode == DOTNET_HASH)
67           {
68             return LanguageType::DOTNET;
69           }
70           else if (hashCode == BASE_HASH)
71           {
72             return LanguageType::BASE;
73           }
74           else if (hashCode == PHP_HASH)
75           {
76             return LanguageType::PHP;
77           }
78           EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
79           if(overflowContainer)
80           {
81             overflowContainer->StoreOverflow(hashCode, name);
82             return static_cast<LanguageType>(hashCode);
83           }
84 
85           return LanguageType::NOT_SET;
86         }
87 
GetNameForLanguageType(LanguageType enumValue)88         Aws::String GetNameForLanguageType(LanguageType enumValue)
89         {
90           switch(enumValue)
91           {
92           case LanguageType::JAVA:
93             return "JAVA";
94           case LanguageType::PYTHON:
95             return "PYTHON";
96           case LanguageType::NODE_JS:
97             return "NODE_JS";
98           case LanguageType::RUBY:
99             return "RUBY";
100           case LanguageType::GOLANG:
101             return "GOLANG";
102           case LanguageType::DOCKER:
103             return "DOCKER";
104           case LanguageType::ANDROID_:
105             return "ANDROID";
106           case LanguageType::DOTNET:
107             return "DOTNET";
108           case LanguageType::BASE:
109             return "BASE";
110           case LanguageType::PHP:
111             return "PHP";
112           default:
113             EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
114             if(overflowContainer)
115             {
116               return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
117             }
118 
119             return {};
120           }
121         }
122 
123       } // namespace LanguageTypeMapper
124     } // namespace Model
125   } // namespace CodeBuild
126 } // namespace Aws
127