AWS SDK for C++

AWS SDK for C++ Version 1.11.606
Loading...
Searching...
No Matches
EventHeader.h
1
6#pragma once
7
8#include <aws/core/Core_EXPORTS.h>
9#include <aws/core/utils/Array.h>
10#include <aws/core/utils/DateTime.h>
11#include <aws/core/utils/StringUtils.h>
12#include <aws/core/utils/UUID.h>
13#include <aws/core/utils/logging/LogMacros.h>
14#include <aws/core/utils/memory/stl/AWSMap.h>
15#include <aws/core/utils/memory/stl/AWSString.h>
16#include <aws/event-stream/event_stream.h>
17#include <cassert>
18
19#ifdef __MINGW32__
20#pragma GCC diagnostic push
21#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
22#pragma GCC diagnostic ignored "-Wuninitialized"
23#endif
24
25namespace Aws
26{
27 namespace Utils
28 {
29 namespace Event
30 {
31 static const char CLASS_TAG[] = "EventHeader";
36 class AWS_CORE_API EventHeaderValue
37 {
38 public:
39 enum class EventHeaderType
40 {
41 BOOL_TRUE = 0,
42 BOOL_FALSE,
43 BYTE,
44 INT16,
45 INT32,
46 INT64,
47 BYTE_BUF,
48 STRING,
49 /* 64 bit integer (millis since epoch) */
50 TIMESTAMP,
51 UUID,
52 UNKNOWN
53 };
54
55 EventHeaderValue() : m_eventHeaderType(EventHeaderType::UNKNOWN), m_eventHeaderStaticValue({0}) {}
56
57 EventHeaderValue(aws_event_stream_header_value_pair* header) :
58 m_eventHeaderType(static_cast<EventHeaderType>(header->header_value_type)),
59 m_eventHeaderStaticValue({0})
60 {
61 switch (m_eventHeaderType)
62 {
63 case EventHeaderType::BOOL_TRUE:
64 case EventHeaderType::BOOL_FALSE:
65 m_eventHeaderStaticValue.boolValue = aws_event_stream_header_value_as_bool(header) != 0;
66 break;
67 case EventHeaderType::BYTE:
68 m_eventHeaderStaticValue.byteValue = aws_event_stream_header_value_as_byte(header);
69 break;
70 case EventHeaderType::INT16:
71 m_eventHeaderStaticValue.int16Value = aws_event_stream_header_value_as_int16(header);
72 break;
73 case EventHeaderType::INT32:
74 m_eventHeaderStaticValue.int32Value = aws_event_stream_header_value_as_int32(header);
75 break;
76 case EventHeaderType::INT64:
77 m_eventHeaderStaticValue.int64Value = aws_event_stream_header_value_as_int64(header);
78 break;
79 case EventHeaderType::BYTE_BUF:
80 m_eventHeaderVariableLengthValue = ByteBuffer(static_cast<uint8_t*>(aws_event_stream_header_value_as_bytebuf(header).buffer), header->header_value_len);
81 break;
82 case EventHeaderType::STRING:
83 m_eventHeaderVariableLengthValue = ByteBuffer(static_cast<uint8_t*>(aws_event_stream_header_value_as_string(header).buffer), header->header_value_len);
84 break;
85 case EventHeaderType::TIMESTAMP:
86 m_eventHeaderStaticValue.timestampValue = aws_event_stream_header_value_as_timestamp(header);
87 break;
88 case EventHeaderType::UUID:
89 assert(header->header_value_len == 16u);
90 m_eventHeaderVariableLengthValue = ByteBuffer(static_cast<uint8_t*>(aws_event_stream_header_value_as_uuid(header).buffer), header->header_value_len);
91 break;
92 default:
93 AWS_LOG_ERROR(CLASS_TAG, "Encountered unknown type of header.");
94 break;
95 }
96 };
97
98 EventHeaderValue(const Aws::String& s) :
99 m_eventHeaderType(EventHeaderType::STRING),
100 m_eventHeaderVariableLengthValue(reinterpret_cast<const uint8_t*>(s.data()), s.length()),
101 m_eventHeaderStaticValue({0})
102 {
103 }
104
105 EventHeaderValue(const ByteBuffer& bb) :
106 m_eventHeaderType(EventHeaderType::BYTE_BUF),
107 m_eventHeaderVariableLengthValue(bb),
108 m_eventHeaderStaticValue({0})
109 {
110 }
111
112 EventHeaderValue(ByteBuffer&& bb) :
113 m_eventHeaderType(EventHeaderType::BYTE_BUF),
114 m_eventHeaderVariableLengthValue(std::move(bb)),
115 m_eventHeaderStaticValue({0})
116 {
117 }
118
119
120 explicit EventHeaderValue(unsigned char byte) :
121 m_eventHeaderType(EventHeaderType::BYTE),
122 m_eventHeaderStaticValue({0})
123 {
124 m_eventHeaderStaticValue.byteValue = byte;
125 }
126
127 explicit EventHeaderValue(bool b) :
128 m_eventHeaderType(b ? EventHeaderType::BOOL_TRUE : EventHeaderType::BOOL_FALSE),
129 m_eventHeaderStaticValue({0})
130 {
131 m_eventHeaderStaticValue.boolValue = b;
132 }
133
134 explicit EventHeaderValue(int16_t n) :
135 m_eventHeaderType(EventHeaderType::INT16),
136 m_eventHeaderStaticValue({0})
137 {
138 m_eventHeaderStaticValue.int16Value = n;
139 }
140
141 explicit EventHeaderValue(int32_t n) :
142 m_eventHeaderType(EventHeaderType::INT32),
143 m_eventHeaderStaticValue({0})
144 {
145 m_eventHeaderStaticValue.int32Value = n;
146 }
147
148 explicit EventHeaderValue(int64_t n, EventHeaderType type = EventHeaderType::INT64) :
149 m_eventHeaderType(type),
150 m_eventHeaderStaticValue({0})
151 {
152 if (type == EventHeaderType::TIMESTAMP)
153 {
154 m_eventHeaderStaticValue.timestampValue = n;
155 }
156 else
157 {
158 m_eventHeaderStaticValue.int64Value = n;
159 }
160 }
161
162 EventHeaderType GetType() const { return m_eventHeaderType; }
163
164
165 static EventHeaderType GetEventHeaderTypeForName(const Aws::String& name);
166 static Aws::String GetNameForEventHeaderType(EventHeaderType value);
167
172 inline bool GetEventHeaderValueAsBoolean() const
173 {
174 assert(m_eventHeaderType == EventHeaderType::BOOL_TRUE || m_eventHeaderType == EventHeaderType::BOOL_FALSE);
175 if (m_eventHeaderType != EventHeaderType::BOOL_TRUE && m_eventHeaderType != EventHeaderType::BOOL_FALSE)
176 {
177 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is TRUE or FALSE, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
178 return false;
179 }
180 return m_eventHeaderStaticValue.boolValue;
181 }
182
187 inline uint8_t GetEventHeaderValueAsByte() const
188 {
189 assert(m_eventHeaderType == EventHeaderType::BYTE);
190 if (m_eventHeaderType != EventHeaderType::BYTE)
191 {
192 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is BYTE, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
193 return static_cast<uint8_t>(0);
194 }
195 return m_eventHeaderStaticValue.byteValue;
196 }
197
202 inline int16_t GetEventHeaderValueAsInt16() const
203 {
204 assert(m_eventHeaderType == EventHeaderType::INT16);
205 if (m_eventHeaderType != EventHeaderType::INT16)
206 {
207 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is INT16, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
208 return static_cast<int16_t>(0);
209 }
210 return m_eventHeaderStaticValue.int16Value;
211 }
212
217 inline int32_t GetEventHeaderValueAsInt32() const
218 {
219 assert(m_eventHeaderType == EventHeaderType::INT32);
220 if (m_eventHeaderType != EventHeaderType::INT32)
221 {
222 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is INT32, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
223 return static_cast<int32_t>(0);
224 }
225 return m_eventHeaderStaticValue.int32Value;
226 }
227
232 inline int64_t GetEventHeaderValueAsInt64() const
233 {
234 assert(m_eventHeaderType == EventHeaderType::INT64);
235 if (m_eventHeaderType != EventHeaderType::INT64)
236 {
237 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is INT64, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
238 return static_cast<uint64_t>(0);
239 }
240 return m_eventHeaderStaticValue.int64Value;
241 }
242
247 inline ByteBuffer GetEventHeaderValueAsBytebuf() const
248 {
249 assert(m_eventHeaderType == EventHeaderType::BYTE_BUF);
250 if (m_eventHeaderType != EventHeaderType::BYTE_BUF)
251 {
252 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is BYTE_BUF, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
253 return ByteBuffer();
254 }
255 return m_eventHeaderVariableLengthValue;
256 }
257
262 inline Aws::String GetEventHeaderValueAsString() const
263 {
264 assert(m_eventHeaderType == EventHeaderType::STRING);
265 if (m_eventHeaderType != EventHeaderType::STRING)
266 {
267 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is STRING, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
268 return {};
269 }
270 return Aws::String(reinterpret_cast<char*>(m_eventHeaderVariableLengthValue.GetUnderlyingData()), m_eventHeaderVariableLengthValue.GetLength());
271 }
272
277 inline int64_t GetEventHeaderValueAsTimestamp() const
278 {
279 assert(m_eventHeaderType == EventHeaderType::TIMESTAMP);
280 if (m_eventHeaderType != EventHeaderType::TIMESTAMP)
281 {
282 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is TIMESTAMP, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
283 return static_cast<int64_t>(0);
284 }
285 return m_eventHeaderStaticValue.timestampValue;
286 }
287
292 inline Aws::Utils::UUID GetEventHeaderValueAsUuid() const
293 {
294 assert(m_eventHeaderType == EventHeaderType::UUID);
295 assert(m_eventHeaderVariableLengthValue.GetLength() == 16u);
296 if (m_eventHeaderType != EventHeaderType::UUID)
297 {
298 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Expected event header type is UUID, but encountered " << GetNameForEventHeaderType(m_eventHeaderType));
299 char uuid[32] = {0};
300 return Aws::Utils::UUID(uuid);
301 }
302 return Aws::Utils::UUID(m_eventHeaderVariableLengthValue.GetUnderlyingData());
303 }
304
305 inline const ByteBuffer& GetUnderlyingBuffer() const
306 {
307 return m_eventHeaderVariableLengthValue;
308 }
309
310 inline Aws::String ToString() const
311 {
312 switch (m_eventHeaderType)
313 {
314 case EventHeaderType::BOOL_TRUE:
315 case EventHeaderType::BOOL_FALSE:
316 return Utils::StringUtils::to_string(GetEventHeaderValueAsBoolean());
317 case EventHeaderType::BYTE:
318 return Utils::StringUtils::to_string(GetEventHeaderValueAsByte());
319 case EventHeaderType::INT16:
320 return Utils::StringUtils::to_string(GetEventHeaderValueAsInt16());
321 case EventHeaderType::INT32:
322 return Utils::StringUtils::to_string(GetEventHeaderValueAsInt32());
323 case EventHeaderType::INT64:
324 return Utils::StringUtils::to_string(GetEventHeaderValueAsInt64());
325 case EventHeaderType::BYTE_BUF:
326 return Aws::String(reinterpret_cast<char*>(GetEventHeaderValueAsBytebuf().GetUnderlyingData()), GetEventHeaderValueAsBytebuf().GetLength());
327 case EventHeaderType::STRING:
328 return GetEventHeaderValueAsString();
329 case EventHeaderType::TIMESTAMP:
330 return Aws::Utils::DateTime(GetEventHeaderValueAsTimestamp()).ToGmtString(Aws::Utils::DateFormat::RFC822);
331 case EventHeaderType::UUID:
332 return GetEventHeaderValueAsUuid();
333 case EventHeaderType::UNKNOWN:
334 default:
335 AWS_LOGSTREAM_ERROR(CLASS_TAG, "Cannot transform EventHeader value to string: type is unknown");
336 return {};
337 }
338 }
339
340 private:
341 EventHeaderType m_eventHeaderType;
342 ByteBuffer m_eventHeaderVariableLengthValue;
343 union
344 {
345 int64_t timestampValue;
346 int64_t int64Value;
347 int32_t int32Value;
348 int16_t int16Value;
349 uint8_t byteValue;
350 bool boolValue;
351 } m_eventHeaderStaticValue;
352 };
353
354 typedef std::pair<Aws::String, EventHeaderValue> EventHeaderValuePair;
355 typedef Aws::Map<Aws::String, EventHeaderValue> EventHeaderValueCollection;
356 }
357 }
358}
359
360#ifdef __MINGW32__
361#pragma GCC diagnostic pop
362#endif
Aws::Utils::DateTime::ToGmtString
Aws::String ToGmtString(DateFormat format) const
Aws::Utils::Event::EventHeaderValue::EventHeaderValue
EventHeaderValue(int64_t n, EventHeaderType type=EventHeaderType::INT64)
Definition EventHeader.h:148
Aws::Utils::Event::EventHeaderValue::GetNameForEventHeaderType
static Aws::String GetNameForEventHeaderType(EventHeaderType value)
Aws::Utils::Event::EventHeaderValue::GetEventHeaderValueAsString
Aws::String GetEventHeaderValueAsString() const
Definition EventHeader.h:262
Aws::Utils::Event::EventHeaderValue::GetType
EventHeaderType GetType() const
Definition EventHeader.h:162
Aws::Utils::Event::EventHeaderValue::EventHeaderValue
EventHeaderValue(aws_event_stream_header_value_pair *header)
Definition EventHeader.h:57
Aws::Utils::Event::EventHeaderValue::GetUnderlyingBuffer
const ByteBuffer & GetUnderlyingBuffer() const
Definition EventHeader.h:305
Aws::Utils::Event::EventHeaderValue::GetEventHeaderValueAsBytebuf
ByteBuffer GetEventHeaderValueAsBytebuf() const
Definition EventHeader.h:247
Aws::Utils::Event::EventHeaderValue::GetEventHeaderTypeForName
static EventHeaderType GetEventHeaderTypeForName(const Aws::String &name)
Aws::Utils::Event::EventHeaderValue::GetEventHeaderValueAsTimestamp
int64_t GetEventHeaderValueAsTimestamp() const
Definition EventHeader.h:277
Aws::Utils::Event::EventHeaderValue::EventHeaderValue
EventHeaderValue(unsigned char byte)
Definition EventHeader.h:120
Aws::Utils::Event::EventHeaderValue::EventHeaderValue
EventHeaderValue(const ByteBuffer &bb)
Definition EventHeader.h:105
Aws::Utils::Event::EventHeaderValue::GetEventHeaderValueAsUuid
Aws::Utils::UUID GetEventHeaderValueAsUuid() const
Definition EventHeader.h:292
Aws::Utils::Event::EventHeaderValue::EventHeaderValue
EventHeaderValue(const Aws::String &s)
Definition EventHeader.h:98
Aws::Utils::Event::EventHeaderValueCollection
Aws::Map< Aws::String, EventHeaderValue > EventHeaderValueCollection
Definition EventHeader.h:355
Aws::Utils::Event::EventHeaderValuePair
std::pair< Aws::String, EventHeaderValue > EventHeaderValuePair
Definition EventHeader.h:354
Aws::Utils::Event::CLASS_TAG
static const char CLASS_TAG[]
Definition EventHeader.h:31
Aws::Map
std::map< K, V, std::less< K >, Aws::Allocator< std::pair< const K, V > > > Map
Definition AWSMap.h:20
Aws::String
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
Definition AWSString.h:97
Generated by doxygen 1.9.8
Privacy | Site terms | Cookie preferences