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