blob: de8b904775b7f584a7a39a3476f9d4c144590c58 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/core/utils/event/EventMessage.h>
#include <aws/core/utils/HashingUtils.h>
#include <algorithm>
#include <iterator>
namespace Aws
{
namespace Utils
{
namespace Event
{
const char EVENT_TYPE_HEADER[] = ":event-type";
const char CONTENT_TYPE_HEADER[] = ":content-type";
const char MESSAGE_TYPE_HEADER[] = ":message-type";
const char ERROR_CODE_HEADER[] = ":error-code";
const char ERROR_MESSAGE_HEADER[] = ":error-message";
const char EXCEPTION_TYPE_HEADER[] = ":exception-type";
static const int EVENT_HASH = HashingUtils::HashString("event");
static const int ERROR_HASH = HashingUtils::HashString("error");
static const int EXCEPTION_HASH = HashingUtils::HashString("exception");
static const int CONTENT_TYPE_APPLICATION_OCTET_STREAM_HASH = HashingUtils::HashString("application/octet-stream");
static const int CONTENT_TYPE_APPLICATION_JSON_HASH = HashingUtils::HashString("application/json");
static const int CONTENT_TYPE_TEXT_PLAIN_HASH = HashingUtils::HashString("text/plain");
Message::MessageType Message::GetMessageTypeForName(const Aws::String& name)
{
int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
if (hashCode == EVENT_HASH)
{
return MessageType::EVENT;
}
else if (hashCode == ERROR_HASH)
{
return MessageType::REQUEST_LEVEL_ERROR;
}
else if (hashCode == EXCEPTION_HASH)
{
return MessageType::REQUEST_LEVEL_EXCEPTION;
}
else
{
return MessageType::UNKNOWN;
}
}
Aws::String Message::GetNameForMessageType(MessageType value)
{
switch (value)
{
case MessageType::EVENT:
return "event";
case MessageType::REQUEST_LEVEL_ERROR:
return "error";
case MessageType::REQUEST_LEVEL_EXCEPTION:
return "exception";
default:
return "unknown";
}
}
Message::ContentType Message::GetContentTypeForName(const Aws::String& name)
{
int hashCode = Aws::Utils::HashingUtils::HashString(name.c_str());
if (hashCode == CONTENT_TYPE_APPLICATION_OCTET_STREAM_HASH)
{
return ContentType::APPLICATION_OCTET_STREAM;
}
else if (hashCode == CONTENT_TYPE_APPLICATION_JSON_HASH)
{
return ContentType::APPLICATION_JSON;
}
else if (hashCode == CONTENT_TYPE_TEXT_PLAIN_HASH)
{
return ContentType::TEXT_PLAIN;
}
else
{
return ContentType::UNKNOWN;
}
}
Aws::String Message::GetNameForContentType(ContentType value)
{
switch (value)
{
case ContentType::APPLICATION_OCTET_STREAM:
return "application/octet-stream";
case ContentType::APPLICATION_JSON:
return "application/json";
case ContentType::TEXT_PLAIN:
return "text/plain";
default:
return "unknown";
}
}
void Message::Reset()
{
m_totalLength = 0;
m_headersLength = 0;
m_payloadLength = 0;
m_eventHeaders.clear();
m_eventPayload.clear();
}
void Message::WriteEventPayload(const unsigned char* data, size_t length)
{
std::copy(data, data + length, std::back_inserter(m_eventPayload));
}
void Message::WriteEventPayload(const Aws::Vector<unsigned char>& bits)
{
std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
}
void Message::WriteEventPayload(const Aws::String& bits)
{
std::copy(bits.cbegin(), bits.cend(), std::back_inserter(m_eventPayload));
}
} // namespace Event
} // namespace Utils
} // namespace Aws
|
