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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/crt/http/HttpRequestResponse.h>
#include <aws/crt/io/Stream.h>
#include <aws/http/request_response.h>
#include <aws/io/stream.h>
namespace Aws
{
namespace Crt
{
namespace Http
{
HttpMessage::HttpMessage(Allocator *allocator, struct aws_http_message *message) noexcept
: m_allocator(allocator), m_message(message), m_bodyStream(nullptr)
{
if (message)
{
// Acquire a refcount to keep the message alive until this object dies.
aws_http_message_acquire(this->m_message);
}
}
HttpMessage::~HttpMessage() { m_message = aws_http_message_release(m_message); }
std::shared_ptr<Aws::Crt::Io::InputStream> HttpMessage::GetBody() const noexcept { return m_bodyStream; }
bool HttpMessage::SetBody(const std::shared_ptr<Aws::Crt::Io::IStream> &body) noexcept
{
aws_http_message_set_body_stream(m_message, nullptr);
m_bodyStream = nullptr;
if (body != nullptr)
{
m_bodyStream = MakeShared<Io::StdIOStreamInputStream>(m_allocator, body, m_allocator);
if (m_bodyStream == nullptr || !m_bodyStream)
{
return false;
}
aws_http_message_set_body_stream(m_message, m_bodyStream->GetUnderlyingStream());
}
return true;
}
bool HttpMessage::SetBody(const std::shared_ptr<Aws::Crt::Io::InputStream> &body) noexcept
{
m_bodyStream = body;
aws_http_message_set_body_stream(
m_message, m_bodyStream && *m_bodyStream ? m_bodyStream->GetUnderlyingStream() : nullptr);
return true;
}
size_t HttpMessage::GetHeaderCount() const noexcept { return aws_http_message_get_header_count(m_message); }
Optional<HttpHeader> HttpMessage::GetHeader(size_t index) const noexcept
{
HttpHeader header;
if (aws_http_message_get_header(m_message, &header, index) != AWS_OP_SUCCESS)
{
return Optional<HttpHeader>();
}
return Optional<HttpHeader>(header);
}
bool HttpMessage::AddHeader(const HttpHeader &header) noexcept
{
return aws_http_message_add_header(m_message, header) == AWS_OP_SUCCESS;
}
bool HttpMessage::EraseHeader(size_t index) noexcept
{
return aws_http_message_erase_header(m_message, index) == AWS_OP_SUCCESS;
}
HttpRequest::HttpRequest(Allocator *allocator)
: HttpMessage(allocator, aws_http_message_new_request(allocator))
{
// Releas the refcount as it created, since HttpMessage is taking the ownership
aws_http_message_release(this->m_message);
}
HttpRequest::HttpRequest(Allocator *allocator, struct aws_http_message *message)
: HttpMessage(allocator, message)
{
}
Optional<ByteCursor> HttpRequest::GetMethod() const noexcept
{
ByteCursor method;
if (aws_http_message_get_request_method(m_message, &method) != AWS_OP_SUCCESS)
{
return Optional<ByteCursor>();
}
return Optional<ByteCursor>(method);
}
bool HttpRequest::SetMethod(ByteCursor method) noexcept
{
return aws_http_message_set_request_method(m_message, method) == AWS_OP_SUCCESS;
}
Optional<ByteCursor> HttpRequest::GetPath() const noexcept
{
ByteCursor path;
if (aws_http_message_get_request_path(m_message, &path) != AWS_OP_SUCCESS)
{
return Optional<ByteCursor>();
}
return Optional<ByteCursor>(path);
}
bool HttpRequest::SetPath(ByteCursor path) noexcept
{
return aws_http_message_set_request_path(m_message, path) == AWS_OP_SUCCESS;
}
HttpResponse::HttpResponse(Allocator *allocator)
: HttpMessage(allocator, aws_http_message_new_response(allocator))
{
// Releas the refcount as it created, since HttpMessage is taking the ownership
aws_http_message_release(this->m_message);
}
Optional<int> HttpResponse::GetResponseCode() const noexcept
{
int response = 0;
if (aws_http_message_get_response_status(m_message, &response) != AWS_OP_SUCCESS)
{
return Optional<int>();
}
return response;
}
bool HttpResponse::SetResponseCode(int response) noexcept
{
return aws_http_message_set_response_status(m_message, response) == AWS_OP_SUCCESS;
}
} // namespace Http
} // namespace Crt
} // namespace Aws
|
