GCC Code Coverage Report

Line	Branch	Exec	Source
1			//
2			// Copyright (c) 2020 Vinnie Falco (vinnie.falco@gmail.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/json
8			//
9
10			#ifndef BOOST_JSON_STATIC_RESOURCE_HPP
11			#define BOOST_JSON_STATIC_RESOURCE_HPP
12
13			#include <boost/container/pmr/memory_resource.hpp>
14			#include <boost/json/detail/config.hpp>
15			#include <boost/json/is_deallocate_trivial.hpp>
16			#include <cstddef>
17
18			namespace boost {
19			namespace json {
20
21			#ifdef _MSC_VER
22			#pragma warning(push)
23			#pragma warning(disable: 4275) // non dll-interface class used as base for dll-interface class
24			#endif
25
26			//----------------------------------------------------------
27
28			/** A resource using a caller-owned buffer, with a trivial deallocate.
29
30			This memory resource is a special-purpose resource that releases allocated
31			memory only when the resource is destroyed (or when @ref release is
32			called). It has a trivial deallocate function; that is, the metafunction
33			@ref is_deallocate_trivial returns `true`.
34
35			The resource is constructed from a caller-owned buffer from which
36			subsequent calls to allocate are apportioned. When a memory request cannot
37			be satisfied from the free bytes remaining in the buffer, the allocation
38			request fails with the exception `std::bad_alloc`.
39
40			@par Example
41			This parses a JSON text into a value which uses a local stack buffer, then
42			prints the result.
43
44			@code
45			unsigned char buf[ 4000 ];
46			static_resource mr( buf );
47
48			// Parse the string, using our memory resource
49			value const jv = parse( "[1,2,3]", &mr );
50
51			// Print the JSON
52			std::cout << jv;
53			@endcode
54
55			@par Thread Safety
56			Members of the same instance may not be called concurrently.
57
58			@see https://en.wikipedia.org/wiki/Region-based_memory_management
59			*/
60			class
61			BOOST_JSON_DECL
62			BOOST_SYMBOL_VISIBLE
63			static_resource final
64			: public container::pmr::memory_resource
65			{
66			void* p_;
67			std::size_t n_;
68			std::size_t size_;
69
70			public:
71			/** Assignment operator.
72
73			The type is neither copyable nor movable, so this operator is deleted.
74			*/
75			static_resource& operator=(
76			static_resource const&) = delete;
77
78			/** Constructors.
79
80			These construct the resource to use the specified buffer for subsequent
81			calls to allocate. When the buffer is exhausted, allocate will throw
82			`std::bad_alloc`.
83
84			Ownership of `buffer` is not transferred; the caller is responsible for
85			ensuring that its lifetime extends until the resource is destroyed.
86
87			Overload **(5)** is the copy constructor. The type is neither copyable
88			nor movable, so this overload is deleted.
89
90			@par Complexity
91			Constant.
92
93			@par Exception Safety
94			No-throw guarantee.
95
96			@param buffer The buffer to use.
97			@param size The number of valid bytes pointed to by `buffer`.
98
99			@{
100			*/
101			static_resource(
102			unsigned char* buffer,
103			std::size_t size) noexcept;
104
105			#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)
106			static_resource(
107			std::byte* buffer,
108			std::size_t size) noexcept
109			: static_resource(reinterpret_cast<
110			unsigned char*>(buffer), size)
111			{
112			}
113			#endif
114
115			/** Overload
116
117			@tparam N The size of `buffer`.
118			@param buffer
119			*/
120			template<std::size_t N>
121			explicit
122		3	static_resource(
123			unsigned char(&buffer)[N]) noexcept
124		3	: static_resource(&buffer[0], N)
125			{
126		3	}
127
128			#if defined(__cpp_lib_byte) || defined(BOOST_JSON_DOCS)
129			/** Overload
130
131			@tparam N
132			@param buffer
133			*/
134			template<std::size_t N>
135			explicit
136			static_resource(
137			std::byte(&buffer)[N]) noexcept
138			: static_resource(&buffer[0], N)
139			{
140			}
141			#endif
142
143			#ifndef BOOST_JSON_DOCS
144			// Safety net for accidental buffer overflows
145			template<std::size_t N>
146			static_resource(
147			unsigned char(&buffer)[N], std::size_t n) noexcept
148			: static_resource(&buffer[0], n)
149			{
150			// If this goes off, check your parameters
151			// closely, chances are you passed an array
152			// thinking it was a pointer.
153			BOOST_ASSERT(n <= N);
154			}
155
156			#ifdef __cpp_lib_byte
157			// Safety net for accidental buffer overflows
158			template<std::size_t N>
159			static_resource(
160			std::byte(&buffer)[N], std::size_t n) noexcept
161			: static_resource(&buffer[0], n)
162			{
163			// If this goes off, check your parameters
164			// closely, chances are you passed an array
165			// thinking it was a pointer.
166			BOOST_ASSERT(n <= N);
167			}
168			#endif
169			#endif
170
171			/// Overload
172			static_resource(
173			static_resource const&) = delete;
174			/// @}
175
176			/** Release all allocated memory.
177
178			This function resets the buffer provided upon construction so that all
179			of the valid bytes are available for subsequent allocation.
180
181			@par Complexity
182			Constant
183
184			@par Exception Safety
185			No-throw guarantee.
186			*/
187			void
188			release() noexcept;
189
190			protected:
191			#ifndef BOOST_JSON_DOCS
192			void*
193			do_allocate(
194			std::size_t n,
195			std::size_t align) override;
196
197			void
198			do_deallocate(
199			void* p,
200			std::size_t n,
201			std::size_t align) override;
202
203			bool
204			do_is_equal(
205			memory_resource const& mr
206			) const noexcept override;
207			#endif
208			};
209
210			#ifdef _MSC_VER
211			#pragma warning(pop)
212			#endif
213
214			template<>
215			struct is_deallocate_trivial<
216			static_resource>
217			{
218			static constexpr bool value = true;
219			};
220
221			} // namespace json
222			} // namespace boost
223
224			#endif
225