]>
Commit | Line | Data |
---|---|---|
b32b8144 FG |
1 | // |
2 | // Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com) | |
3 | // | |
4 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
5 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
6 | // | |
7 | // Official repository: https://github.com/boostorg/beast | |
8 | // | |
9 | ||
10 | #ifndef BOOST_BEAST_HTTP_VECTOR_BODY_HPP | |
11 | #define BOOST_BEAST_HTTP_VECTOR_BODY_HPP | |
12 | ||
13 | #include <boost/beast/core/detail/config.hpp> | |
14 | #include <boost/beast/http/error.hpp> | |
15 | #include <boost/beast/http/message.hpp> | |
16 | #include <boost/beast/core/detail/type_traits.hpp> | |
17 | #include <boost/asio/buffer.hpp> | |
18 | #include <boost/optional.hpp> | |
19 | #include <cstdint> | |
20 | #include <limits> | |
21 | #include <memory> | |
22 | #include <stdexcept> | |
23 | #include <string> | |
24 | #include <utility> | |
25 | ||
26 | namespace boost { | |
27 | namespace beast { | |
28 | namespace http { | |
29 | ||
30 | /** A @b Body using `std::vector` | |
31 | ||
32 | This body uses `std::vector` as a memory-based container | |
33 | for holding message payloads. Messages using this body type | |
34 | may be serialized and parsed. | |
35 | */ | |
36 | template<class T, class Allocator = std::allocator<T>> | |
37 | struct vector_body | |
38 | { | |
39 | private: | |
40 | static_assert(sizeof(T) == 1 && | |
41 | std::is_integral<T>::value, | |
42 | "T requirements not met"); | |
43 | ||
44 | public: | |
45 | /** The type of container used for the body | |
46 | ||
47 | This determines the type of @ref message::body | |
48 | when this body type is used with a message container. | |
49 | */ | |
50 | using value_type = std::vector<T, Allocator>; | |
51 | ||
52 | /** Returns the payload size of the body | |
53 | ||
54 | When this body is used with @ref message::prepare_payload, | |
55 | the Content-Length will be set to the payload size, and | |
56 | any chunked Transfer-Encoding will be removed. | |
57 | */ | |
58 | static | |
59 | std::uint64_t | |
60 | size(value_type const& body) | |
61 | { | |
62 | return body.size(); | |
63 | } | |
64 | ||
65 | /** The algorithm for parsing the body | |
66 | ||
67 | Meets the requirements of @b BodyReader. | |
68 | */ | |
69 | #if BOOST_BEAST_DOXYGEN | |
70 | using reader = implementation_defined; | |
71 | #else | |
72 | class reader | |
73 | { | |
74 | value_type& body_; | |
75 | ||
76 | public: | |
77 | template<bool isRequest, class Fields> | |
78 | explicit | |
11fdf7f2 TL |
79 | reader(header<isRequest, Fields>&, value_type& b) |
80 | : body_(b) | |
b32b8144 FG |
81 | { |
82 | } | |
83 | ||
84 | void | |
85 | init(boost::optional< | |
86 | std::uint64_t> const& length, error_code& ec) | |
87 | { | |
88 | if(length) | |
89 | { | |
90 | if(static_cast<std::size_t>(*length) != *length) | |
91 | { | |
92 | ec = error::buffer_overflow; | |
93 | return; | |
94 | } | |
95 | try | |
96 | { | |
97 | body_.reserve( | |
98 | static_cast<std::size_t>(*length)); | |
99 | } | |
100 | catch(std::exception const&) | |
101 | { | |
102 | ec = error::buffer_overflow; | |
103 | return; | |
104 | } | |
105 | } | |
106 | ec.assign(0, ec.category()); | |
107 | } | |
108 | ||
109 | template<class ConstBufferSequence> | |
110 | std::size_t | |
111 | put(ConstBufferSequence const& buffers, | |
112 | error_code& ec) | |
113 | { | |
114 | using boost::asio::buffer_size; | |
115 | using boost::asio::buffer_copy; | |
116 | auto const n = buffer_size(buffers); | |
117 | auto const len = body_.size(); | |
118 | try | |
119 | { | |
120 | body_.resize(len + n); | |
121 | } | |
122 | catch(std::exception const&) | |
123 | { | |
124 | ec = error::buffer_overflow; | |
125 | return 0; | |
126 | } | |
127 | ec.assign(0, ec.category()); | |
128 | return buffer_copy(boost::asio::buffer( | |
129 | &body_[0] + len, n), buffers); | |
130 | } | |
131 | ||
132 | void | |
133 | finish(error_code& ec) | |
134 | { | |
135 | ec.assign(0, ec.category()); | |
136 | } | |
137 | }; | |
138 | #endif | |
139 | ||
140 | /** The algorithm for serializing the body | |
141 | ||
142 | Meets the requirements of @b BodyWriter. | |
143 | */ | |
144 | #if BOOST_BEAST_DOXYGEN | |
145 | using writer = implementation_defined; | |
146 | #else | |
147 | class writer | |
148 | { | |
149 | value_type const& body_; | |
150 | ||
151 | public: | |
152 | using const_buffers_type = | |
153 | boost::asio::const_buffer; | |
154 | ||
155 | template<bool isRequest, class Fields> | |
156 | explicit | |
11fdf7f2 TL |
157 | writer(header<isRequest, Fields> const&, value_type const& b) |
158 | : body_(b) | |
b32b8144 FG |
159 | { |
160 | } | |
161 | ||
162 | void | |
163 | init(error_code& ec) | |
164 | { | |
165 | ec.assign(0, ec.category()); | |
166 | } | |
167 | ||
168 | boost::optional<std::pair<const_buffers_type, bool>> | |
169 | get(error_code& ec) | |
170 | { | |
171 | ec.assign(0, ec.category()); | |
172 | return {{const_buffers_type{ | |
173 | body_.data(), body_.size()}, false}}; | |
174 | } | |
175 | }; | |
176 | #endif | |
177 | }; | |
178 | ||
179 | } // http | |
180 | } // beast | |
181 | } // boost | |
182 | ||
183 | #endif |