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			// Copyright (c) 2025 Mohammad Nejati
5			//
6			// Distributed under the Boost Software License, Version 1.0. (See accompanying
7			// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
8			//
9			// Official repository: https://github.com/cppalliance/http_proto
10			//
11
12			#ifndef BOOST_HTTP_PROTO_RESPONSE_HPP
13			#define BOOST_HTTP_PROTO_RESPONSE_HPP
14
15			#include <boost/http_proto/response_base.hpp>
16
17			namespace boost {
18			namespace http_proto {
19
20			/** Container for HTTP responses
21			*/
22			class response
23			: public response_base
24			{
25			public:
26			/** Constructor
27			*/
28			BOOST_HTTP_PROTO_DECL
29			response() noexcept;
30
31			/** Constructor
32			*/
33			BOOST_HTTP_PROTO_DECL
34			explicit
35			response(
36			core::string_view s);
37
38			/** Constructor
39
40			Construct a response container which allocates
41			`storage_size` bytes for storing the header.
42			Attempting to grow the container beyond
43			this amount will result in an exception.
44			The storage is also used internally to store
45			instances of an implementation-defined type.
46			The requested number of bytes will be aligned
47			accordingly (currently the alignment requirement is 4).
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 storage size of `0` does not
58			throw and the maximum capacity is set to an
59			implementation-defined limit observable via
60			@ref max_capacity_in_bytes().
61
62			@param storage_size The initial and final size of
63			the storage.
64
65			@code
66			boost::http_proto::response
67			make_response(std::string_view server)
68			{
69			std::size_t size = 4096;
70			// res.buffer() is now stable
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 storage_size);
89
90			/** Constructor
91
92			Construct a response container which allocates
93			`storage_size` bytes for storing the header, with an
94			upper limit of `max_storage_size`. Attempting to
95			grow the container beyond its maximum will result in
96			an exception. The storage is also used internally to
97			store instances of an implementation-defined type.
98			Both values will be aligned accordingly (currently
99			the alignment requirement is 4).
100
101			<br/>
102
103			This constructor is useful when there's a best-fit
104			guess for an initial header size but we still wish
105			to permit reallocating and growing the container to
106			some upper limit.
107
108			<br/>
109
110			Passing an initial size of `0` does not throw.
111
112			@param storage_size The initial size of the storage.
113
114			@param max_storage_size The maximum size of the
115			allocated storage. Any operation that attempts to
116			grow the container beyond this value throws
117			`std::length_error`.
118
119			@throws std::length_error Thrown if `size > max_size`
120
121			@code
122			boost::http_proto::response
123			make_response(std::string_view host)
124			{
125			std::size_t size = 4096;
126			boost::http_proto::response res(size, 2 * size);
127			BOOST_ASSERT(
128			res.max_capacity_in_bytes(), 2 * 4096);
129
130			// uses spare capacity so that reallocations
131			// are avoided
132			res.append(
133			boost::http_proto::field::host, host);
134			res.append(
135			boost::http_proto::field::connection, "close");
136			return res;
137			}
138			@endcode
139			*/
140			BOOST_HTTP_PROTO_DECL
141			response(
142			std::size_t storage_size,
143			std::size_t max_storage_size);
144
145			/** Constructor
146			*/
147			BOOST_HTTP_PROTO_DECL
148			response(
149			http_proto::status sc,
150			http_proto::version v);
151
152			/** Constructor
153			*
154			* The start-line of the response will contain the standard
155			* text for the supplied status code and the HTTP version
156			* will be defaulted to 1.1.
157			*/
158			BOOST_HTTP_PROTO_DECL
159			explicit
160			response(
161			http_proto::status sc);
162
163			/** Constructor
164
165			The moved-from object will be
166			left in the default-constructed
167			state.
168			*/
169			BOOST_HTTP_PROTO_DECL
170			response(response&& other) noexcept;
171
172			/** Constructor
173			*/
174			BOOST_HTTP_PROTO_DECL
175			response(response const& other);
176
177			/** Constructor
178			*/
179			BOOST_HTTP_PROTO_DECL
180			response(
181			response_view const& other);
182
183			/** Assignment
184			*/
185			BOOST_HTTP_PROTO_DECL
186			response&
187			operator=(
188			response&& other) noexcept;
189
190			/** Assignment
191			*/
192			response&
193		1	operator=(
194			response const& other)
195			{
196		1	copy_impl(*other.ph_);
197		1	return *this;
198			}
199
200			/** Assignment
201			*/
202			response&
203		1	operator=(
204			response_view const& other)
205			{
206		1	copy_impl(*other.ph_);
207		1	return *this;
208			}
209
210			/** Swap this with another instance
211			*/
212			void
213		4	swap(response& other) noexcept
214			{
215		4	h_.swap(other.h_);
216		4	}
217
218			/** Swap two instances
219			*/
220			// hidden friend
221			friend
222			void
223			swap(
224			response& t0,
225			response& t1) noexcept
226			{
227			t0.swap(t1);
228			}
229			};
230
231			} // http_proto
232			} // boost
233
234			#endif
235