GCC Code Coverage Report

Line	Branch	Exec	Source
1			//
2			// Copyright (c) 2021 Vinnie Falco (vinnie.falco@gmail.com)
3			// Copyright (c) 2024 Christian Mazakas
4			//
5			// Distributed under the Boost Software License, Version 1.0. (See accompanying
6			// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7			//
8			// Official repository: https://github.com/cppalliance/http_proto
9			//
10
11			#ifndef BOOST_HTTP_PROTO_RESPONSE_HPP
12			#define BOOST_HTTP_PROTO_RESPONSE_HPP
13
14			#include <boost/http_proto/detail/config.hpp>
15			#include <boost/http_proto/message_base.hpp>
16			#include <boost/http_proto/response_view.hpp>
17			#include <boost/http_proto/status.hpp>
18
19			namespace boost {
20			namespace http_proto {
21
22			/** Container for HTTP responses
23			*/
24			class BOOST_SYMBOL_VISIBLE
25			response
26			: public message_base
27			{
28			public:
29			/** Constructor
30			*/
31			BOOST_HTTP_PROTO_DECL
32			response() noexcept;
33
34			/** Constructor
35			*/
36			BOOST_HTTP_PROTO_DECL
37			explicit
38			response(
39			core::string_view s);
40
41			/** Constructor
42
43			Construct a response which allocates `size` bytes
44			for storing the response header. The provided `size`
45			will be aligned up as required by the implementation.
46			This size will also be used as the limit for
47			growing the header.
48
49			<br/>
50
51			This constructor is useful when an upper-bound size
52			of the response is known ahead of time and we want
53			to prevent reallocations.
54
55			<br/>
56
57			Passing an initial size of `0` does not throw and
58			the maximum capacity is set to an
59			implementation-defined limit.
60
61			@param size Initial and final size, in bytes, of
62			the backing allocation for the response's header.
63			Any operation that attempts to grow the container
64			beyond this size will throw `std::length_error`.
65
66			@code
67			boost::http_proto::response
68			make_response(std::string_view server)
69			{
70			std::size_t size = 4096;
71			boost::http_proto::response res(size);
72			BOOST_ASSERT(
73			res.max_capacity_in_bytes(), 4096);
74
75			// uses spare capacity so that reallocations
76			// are avoided
77			res.append(
78			boost::http_proto::field::server, server);
79			res.append(
80			boost::http_proto::field::connection, "close");
81			return res;
82			}
83			@endcode
84			*/
85			BOOST_HTTP_PROTO_DECL
86			explicit
87			response(
88			std::size_t size);
89
90			/** Constructor
91
92			Constructs a response with an initial allocation of
93			`size` bytes used for the response header. The
94			container can regrow up until the limit `max_size`.
95			`size` and `max_size` are aligned up as required by the
96			implementation.
97
98			<br/>
99
100			This constructor is useful when there's a best-fit
101			guess for an initial header size but we still wish
102			to permit reallocating and growing the container to
103			some upper limit.
104
105			<br/>
106
107			Passing an initial size of `0` does not throw.
108
109			@param size Initial size, in bytes, of
110			the backing allocation for the response's header.
111
112			@param max_size Max size, in bytes, of the backing
113			allocation for the response's header. Any operation
114			that attempts to grow the container beyond this
115			size will throw `std::length_error`.
116
117			@throws std::length_error Thrown if `size > max_size`
118
119			@code
120			boost::http_proto::response
121			make_response(std::string_view server)
122			{
123			std::size_t size = 4096;
124			boost::http_proto::response res(size, 2 * size);
125			BOOST_ASSERT(
126			res.max_capacity_in_bytes(), 2 * 4096);
127
128			// uses spare capacity so that reallocations
129			// are avoided
130			res.append(
131			boost::http_proto::field::server, server);
132			res.append(
133			boost::http_proto::field::connection, "close");
134			return res;
135			}
136			@endcode
137			*/
138			BOOST_HTTP_PROTO_DECL
139			response(
140			std::size_t size,
141			std::size_t max_size);
142
143			/** Constructor
144
145			The moved-from object will be
146			left in the default-constructed
147			state.
148			*/
149			BOOST_HTTP_PROTO_DECL
150			response(response&& other) noexcept;
151
152			/** Constructor
153			*/
154			BOOST_HTTP_PROTO_DECL
155			response(response const& other);
156
157			/** Constructor
158			*/
159			BOOST_HTTP_PROTO_DECL
160			response(
161			response_view const& other);
162
163			/** Assignment
164			*/
165			BOOST_HTTP_PROTO_DECL
166			response&
167			operator=(
168			response&& other) noexcept;
169
170			/** Assignment
171			*/
172			response&
173		3	operator=(
174			response const& other)
175			{
176		3	copy_impl(*other.ph_);
177		3	return *this;
178			}
179
180			/** Assignment
181			*/
182			response&
183		1	operator=(
184			response_view const& other)
185			{
186		1	copy_impl(*other.ph_);
187		1	return *this;
188			}
189
190			/** Constructor
191			*/
192			BOOST_HTTP_PROTO_DECL
193			response(
194			http_proto::status sc,
195			http_proto::version v);
196
197			/** Constructor
198			*
199			* The start-line of the response will contain the standard
200			* text for the supplied status code and the HTTP version
201			* will be defaulted to 1.1.
202			*/
203			BOOST_HTTP_PROTO_DECL
204			explicit
205			response(
206			http_proto::status sc);
207
208			/** Return a read-only view to the response
209			*/
210		5	operator
211			response_view() const noexcept
212			{
213		5	return response_view(ph_);
214			}
215
216			//--------------------------------------------
217			//
218			// Observers
219			//
220			//--------------------------------------------
221
222			/** Return the reason string
223
224			This field is obsolete in HTTP/1
225			and should only be used for display
226			purposes.
227			*/
228			core::string_view
229		28	reason() const noexcept
230			{
231		56	return core::string_view(
232		28	ph_->cbuf + 13,
233		28	ph_->prefix - 15);
234			}
235
236			/** Return the status code
237			*/
238			http_proto::status
239		28	status() const noexcept
240			{
241		28	return ph_->res.status;
242			}
243
244			/** Return the status code
245			*/
246			unsigned short
247		28	status_int() const noexcept
248			{
249		28	return ph_->res.status_int;
250			}
251
252			/** Return the HTTP version
253			*/
254			http_proto::version
255		28	version() const noexcept
256			{
257		28	return ph_->version;
258			}
259
260			//--------------------------------------------
261			//
262			// Modifiers
263			//
264			//--------------------------------------------
265
266			/** Set the version, status code of the response
267
268			The reason phrase will be set to the
269			standard text for the specified status
270			code.
271
272			@par sc The status code. This must not be
273			@ref http_proto::status::unknown.
274
275			@par v The HTTP-version.
276			*/
277			void
278		13	set_start_line(
279			http_proto::status sc,
280			http_proto::version v =
281			http_proto::version::http_1_1)
282			{
283		13	set_impl(
284			sc,
285			static_cast<
286			unsigned short>(sc),
287			obsolete_reason(sc),
288			v);
289		13	}
290
291			void
292		6	set_start_line(
293			unsigned short si,
294			core::string_view reason,
295			http_proto::version v)
296			{
297		6	set_impl(
298			int_to_status(si),
299			si,
300			reason,
301			v);
302		6	}
303
304			/** Swap this with another instance
305			*/
306			void
307		6	swap(response& other) noexcept
308			{
309		6	h_.swap(other.h_);
310		6	}
311
312			/** Swap two instances
313			*/
314			// hidden friend
315			friend
316			void
317			swap(
318			response& t0,
319			response& t1) noexcept
320			{
321			t0.swap(t1);
322			}
323
324			private:
325			BOOST_HTTP_PROTO_DECL
326			void
327			set_impl(
328			http_proto::status sc,
329			unsigned short si,
330			core::string_view reason,
331			http_proto::version v);
332			};
333
334			} // http_proto
335			} // boost
336
337			#endif
338