static_resource.hpp

100.0% Lines (3/3) 50.0% Functions (2/4) -% Branches (0/0)

Covered Uncovered

static_resource.hpp

3 covered 0 uncovered

Line	Hits	Source Code
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