1 /**
2  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3  * SPDX-License-Identifier: Apache-2.0.
4  */
5 
6 #include <aws/logs/model/StandardUnit.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 CloudWatchLogs
17   {
18     namespace Model
19     {
20       namespace StandardUnitMapper
21       {
22 
23         static const int Seconds_HASH = HashingUtils::HashString("Seconds");
24         static const int Microseconds_HASH = HashingUtils::HashString("Microseconds");
25         static const int Milliseconds_HASH = HashingUtils::HashString("Milliseconds");
26         static const int Bytes_HASH = HashingUtils::HashString("Bytes");
27         static const int Kilobytes_HASH = HashingUtils::HashString("Kilobytes");
28         static const int Megabytes_HASH = HashingUtils::HashString("Megabytes");
29         static const int Gigabytes_HASH = HashingUtils::HashString("Gigabytes");
30         static const int Terabytes_HASH = HashingUtils::HashString("Terabytes");
31         static const int Bits_HASH = HashingUtils::HashString("Bits");
32         static const int Kilobits_HASH = HashingUtils::HashString("Kilobits");
33         static const int Megabits_HASH = HashingUtils::HashString("Megabits");
34         static const int Gigabits_HASH = HashingUtils::HashString("Gigabits");
35         static const int Terabits_HASH = HashingUtils::HashString("Terabits");
36         static const int Percent_HASH = HashingUtils::HashString("Percent");
37         static const int Count_HASH = HashingUtils::HashString("Count");
38         static const int Bytes_Second_HASH = HashingUtils::HashString("Bytes/Second");
39         static const int Kilobytes_Second_HASH = HashingUtils::HashString("Kilobytes/Second");
40         static const int Megabytes_Second_HASH = HashingUtils::HashString("Megabytes/Second");
41         static const int Gigabytes_Second_HASH = HashingUtils::HashString("Gigabytes/Second");
42         static const int Terabytes_Second_HASH = HashingUtils::HashString("Terabytes/Second");
43         static const int Bits_Second_HASH = HashingUtils::HashString("Bits/Second");
44         static const int Kilobits_Second_HASH = HashingUtils::HashString("Kilobits/Second");
45         static const int Megabits_Second_HASH = HashingUtils::HashString("Megabits/Second");
46         static const int Gigabits_Second_HASH = HashingUtils::HashString("Gigabits/Second");
47         static const int Terabits_Second_HASH = HashingUtils::HashString("Terabits/Second");
48         static const int Count_Second_HASH = HashingUtils::HashString("Count/Second");
49         static const int None_HASH = HashingUtils::HashString("None");
50 
51 
GetStandardUnitForName(const Aws::String & name)52         StandardUnit GetStandardUnitForName(const Aws::String& name)
53         {
54           int hashCode = HashingUtils::HashString(name.c_str());
55           if (hashCode == Seconds_HASH)
56           {
57             return StandardUnit::Seconds;
58           }
59           else if (hashCode == Microseconds_HASH)
60           {
61             return StandardUnit::Microseconds;
62           }
63           else if (hashCode == Milliseconds_HASH)
64           {
65             return StandardUnit::Milliseconds;
66           }
67           else if (hashCode == Bytes_HASH)
68           {
69             return StandardUnit::Bytes;
70           }
71           else if (hashCode == Kilobytes_HASH)
72           {
73             return StandardUnit::Kilobytes;
74           }
75           else if (hashCode == Megabytes_HASH)
76           {
77             return StandardUnit::Megabytes;
78           }
79           else if (hashCode == Gigabytes_HASH)
80           {
81             return StandardUnit::Gigabytes;
82           }
83           else if (hashCode == Terabytes_HASH)
84           {
85             return StandardUnit::Terabytes;
86           }
87           else if (hashCode == Bits_HASH)
88           {
89             return StandardUnit::Bits;
90           }
91           else if (hashCode == Kilobits_HASH)
92           {
93             return StandardUnit::Kilobits;
94           }
95           else if (hashCode == Megabits_HASH)
96           {
97             return StandardUnit::Megabits;
98           }
99           else if (hashCode == Gigabits_HASH)
100           {
101             return StandardUnit::Gigabits;
102           }
103           else if (hashCode == Terabits_HASH)
104           {
105             return StandardUnit::Terabits;
106           }
107           else if (hashCode == Percent_HASH)
108           {
109             return StandardUnit::Percent;
110           }
111           else if (hashCode == Count_HASH)
112           {
113             return StandardUnit::Count;
114           }
115           else if (hashCode == Bytes_Second_HASH)
116           {
117             return StandardUnit::Bytes_Second;
118           }
119           else if (hashCode == Kilobytes_Second_HASH)
120           {
121             return StandardUnit::Kilobytes_Second;
122           }
123           else if (hashCode == Megabytes_Second_HASH)
124           {
125             return StandardUnit::Megabytes_Second;
126           }
127           else if (hashCode == Gigabytes_Second_HASH)
128           {
129             return StandardUnit::Gigabytes_Second;
130           }
131           else if (hashCode == Terabytes_Second_HASH)
132           {
133             return StandardUnit::Terabytes_Second;
134           }
135           else if (hashCode == Bits_Second_HASH)
136           {
137             return StandardUnit::Bits_Second;
138           }
139           else if (hashCode == Kilobits_Second_HASH)
140           {
141             return StandardUnit::Kilobits_Second;
142           }
143           else if (hashCode == Megabits_Second_HASH)
144           {
145             return StandardUnit::Megabits_Second;
146           }
147           else if (hashCode == Gigabits_Second_HASH)
148           {
149             return StandardUnit::Gigabits_Second;
150           }
151           else if (hashCode == Terabits_Second_HASH)
152           {
153             return StandardUnit::Terabits_Second;
154           }
155           else if (hashCode == Count_Second_HASH)
156           {
157             return StandardUnit::Count_Second;
158           }
159           else if (hashCode == None_HASH)
160           {
161             return StandardUnit::None;
162           }
163           EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
164           if(overflowContainer)
165           {
166             overflowContainer->StoreOverflow(hashCode, name);
167             return static_cast<StandardUnit>(hashCode);
168           }
169 
170           return StandardUnit::NOT_SET;
171         }
172 
GetNameForStandardUnit(StandardUnit enumValue)173         Aws::String GetNameForStandardUnit(StandardUnit enumValue)
174         {
175           switch(enumValue)
176           {
177           case StandardUnit::Seconds:
178             return "Seconds";
179           case StandardUnit::Microseconds:
180             return "Microseconds";
181           case StandardUnit::Milliseconds:
182             return "Milliseconds";
183           case StandardUnit::Bytes:
184             return "Bytes";
185           case StandardUnit::Kilobytes:
186             return "Kilobytes";
187           case StandardUnit::Megabytes:
188             return "Megabytes";
189           case StandardUnit::Gigabytes:
190             return "Gigabytes";
191           case StandardUnit::Terabytes:
192             return "Terabytes";
193           case StandardUnit::Bits:
194             return "Bits";
195           case StandardUnit::Kilobits:
196             return "Kilobits";
197           case StandardUnit::Megabits:
198             return "Megabits";
199           case StandardUnit::Gigabits:
200             return "Gigabits";
201           case StandardUnit::Terabits:
202             return "Terabits";
203           case StandardUnit::Percent:
204             return "Percent";
205           case StandardUnit::Count:
206             return "Count";
207           case StandardUnit::Bytes_Second:
208             return "Bytes/Second";
209           case StandardUnit::Kilobytes_Second:
210             return "Kilobytes/Second";
211           case StandardUnit::Megabytes_Second:
212             return "Megabytes/Second";
213           case StandardUnit::Gigabytes_Second:
214             return "Gigabytes/Second";
215           case StandardUnit::Terabytes_Second:
216             return "Terabytes/Second";
217           case StandardUnit::Bits_Second:
218             return "Bits/Second";
219           case StandardUnit::Kilobits_Second:
220             return "Kilobits/Second";
221           case StandardUnit::Megabits_Second:
222             return "Megabits/Second";
223           case StandardUnit::Gigabits_Second:
224             return "Gigabits/Second";
225           case StandardUnit::Terabits_Second:
226             return "Terabits/Second";
227           case StandardUnit::Count_Second:
228             return "Count/Second";
229           case StandardUnit::None:
230             return "None";
231           default:
232             EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
233             if(overflowContainer)
234             {
235               return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
236             }
237 
238             return {};
239           }
240         }
241 
242       } // namespace StandardUnitMapper
243     } // namespace Model
244   } // namespace CloudWatchLogs
245 } // namespace Aws
246