1// Temporary buffer implementation -*- C++ -*- 
2 
3// Copyright (C) 2001-2021 Free Software Foundation, Inc. 
4// 
5// This file is part of the GNU ISO C++ Library. This library is free 
6// software; you can redistribute it and/or modify it under the 
7// terms of the GNU General Public License as published by the 
8// Free Software Foundation; either version 3, or (at your option) 
9// any later version. 
10 
11// This library is distributed in the hope that it will be useful, 
12// but WITHOUT ANY WARRANTY; without even the implied warranty of 
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
14// GNU General Public License for more details. 
15 
16// Under Section 7 of GPL version 3, you are granted additional 
17// permissions described in the GCC Runtime Library Exception, version 
18// 3.1, as published by the Free Software Foundation. 
19 
20// You should have received a copy of the GNU General Public License and 
21// a copy of the GCC Runtime Library Exception along with this program; 
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 
23// <http://www.gnu.org/licenses/>. 
24 
25/* 
26 * 
27 * Copyright (c) 1994 
28 * Hewlett-Packard Company 
29 * 
30 * Permission to use, copy, modify, distribute and sell this software 
31 * and its documentation for any purpose is hereby granted without fee, 
32 * provided that the above copyright notice appear in all copies and 
33 * that both that copyright notice and this permission notice appear 
34 * in supporting documentation. Hewlett-Packard Company makes no 
35 * representations about the suitability of this software for any 
36 * purpose. It is provided "as is" without express or implied warranty. 
37 * 
38 * 
39 * Copyright (c) 1996,1997 
40 * Silicon Graphics Computer Systems, Inc. 
41 * 
42 * Permission to use, copy, modify, distribute and sell this software 
43 * and its documentation for any purpose is hereby granted without fee, 
44 * provided that the above copyright notice appear in all copies and 
45 * that both that copyright notice and this permission notice appear 
46 * in supporting documentation. Silicon Graphics makes no 
47 * representations about the suitability of this software for any 
48 * purpose. It is provided "as is" without express or implied warranty. 
49 */ 
50 
51/** @file bits/stl_tempbuf.h 
52 * This is an internal header file, included by other library headers. 
53 * Do not attempt to use it directly. @headername{memory} 
54 */ 
55 
56#ifndef _STL_TEMPBUF_H 
57#define _STL_TEMPBUF_H 1 
58 
59#include <bits/stl_algobase.h> 
60#include <bits/stl_construct.h> 
61 
62namespace std _GLIBCXX_VISIBILITY(default) 
63{ 
64_GLIBCXX_BEGIN_NAMESPACE_VERSION 
65 
66 namespace __detail 
67 { 
68 template<typename _Tp> 
69 inline void 
70 __return_temporary_buffer(_Tp* __p, 
71 size_t __len __attribute__((__unused__))) 
72 { 
73#if __cpp_sized_deallocation 
74 ::operator delete(__p, __len * sizeof(_Tp)); 
75#else 
76 ::operator delete(__p); 
77#endif 
78 } 
79 } 
80 
81 /** 
82 * @brief Allocates a temporary buffer. 
83 * @param __len The number of objects of type Tp. 
84 * @return See full description. 
85 * 
86 * Reinventing the wheel, but this time with prettier spokes! 
87 * 
88 * This function tries to obtain storage for @c __len adjacent Tp 
89 * objects. The objects themselves are not constructed, of course. 
90 * A pair<> is returned containing <em>the buffer s address and 
91 * capacity (in the units of sizeof(_Tp)), or a pair of 0 values if 
92 * no storage can be obtained.</em> Note that the capacity obtained 
93 * may be less than that requested if the memory is unavailable; 
94 * you should compare len with the .second return value. 
95 * 
96 * Provides the nothrow exception guarantee. 
97 */ 
98 template<typename _Tp> 
99 pair<_Tp*, ptrdiff_t> 
100 get_temporary_buffer(ptrdiff_t __len) _GLIBCXX_NOEXCEPT 
101 { 
102 const ptrdiff_t __max = 
103 __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp); 
104 if (__len > __max) 
105 __len = __max; 
106 
107 while (__len > 0) 
108 { 
109 _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), 
110 std::nothrow)); 
111 if (__tmp != 0) 
112 return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); 
113 __len = __len == 1 ? 0 : ((__len + 1) / 2); 
114 } 
115 return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); 
116 } 
117 
118 /** 
119 * @brief The companion to get_temporary_buffer(). 
120 * @param __p A buffer previously allocated by get_temporary_buffer. 
121 * @return None. 
122 * 
123 * Frees the memory pointed to by __p. 
124 */ 
125 template<typename _Tp> 
126 inline void 
127 return_temporary_buffer(_Tp* __p) 
128 { ::operator delete(__p); } 
129 
130 /** 
131 * This class is used in two places: stl_algo.h and ext/memory, 
132 * where it is wrapped as the temporary_buffer class. See 
133 * temporary_buffer docs for more notes. 
134 */ 
135 template<typename _ForwardIterator, typename _Tp> 
136 class _Temporary_buffer 
137 { 
138 // concept requirements 
139 __glibcxx_class_requires(_ForwardIterator, _ForwardIteratorConcept) 
140 
141 public: 
142 typedef _Tp value_type; 
143 typedef value_type* pointer; 
144 typedef pointer iterator; 
145 typedef ptrdiff_t size_type; 
146 
147 protected: 
148 size_type _M_original_len; 
149 size_type _M_len; 
150 pointer _M_buffer; 
151 
152 public: 
153 /// As per Table mumble. 
154 size_type 
155 size() const 
156 { return _M_len; } 
157 
158 /// Returns the size requested by the constructor; may be >size(). 
159 size_type 
160 requested_size() const 
161 { return _M_original_len; } 
162 
163 /// As per Table mumble. 
164 iterator 
165 begin() 
166 { return _M_buffer; } 
167 
168 /// As per Table mumble. 
169 iterator 
170 end() 
171 { return _M_buffer + _M_len; } 
172 
173 /** 
174 * Constructs a temporary buffer of a size somewhere between 
175 * zero and the given length. 
176 */ 
177 _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); 
178 
179 ~_Temporary_buffer() 
180 { 
181 std::_Destroy(_M_buffer, _M_buffer + _M_len); 
182 std::__detail::__return_temporary_buffer(_M_buffer, _M_len); 
183 } 
184 
185 private: 
186 // Disable copy constructor and assignment operator. 
187 _Temporary_buffer(const _Temporary_buffer&); 
188 
189 void 
190 operator=(const _Temporary_buffer&); 
191 }; 
192 
193 
194 template<bool> 
195 struct __uninitialized_construct_buf_dispatch 
196 { 
197 template<typename _Pointer, typename _ForwardIterator> 
198 static void 
199 __ucr(_Pointer __first, _Pointer __last, 
200 _ForwardIterator __seed) 
201 { 
202 if (__first == __last) 
203 return; 
204 
205 _Pointer __cur = __first; 
206 __try 
207 { 
208 std::_Construct(std::__addressof(*__first), 
209 _GLIBCXX_MOVE(*__seed)); 
210 _Pointer __prev = __cur; 
211 ++__cur; 
212 for(; __cur != __last; ++__cur, ++__prev) 
213 std::_Construct(std::__addressof(*__cur), 
214 _GLIBCXX_MOVE(*__prev)); 
215 *__seed = _GLIBCXX_MOVE(*__prev); 
216 } 
217 __catch(...) 
218 { 
219 std::_Destroy(__first, __cur); 
220 __throw_exception_again; 
221 } 
222 } 
223 }; 
224 
225 template<> 
226 struct __uninitialized_construct_buf_dispatch<true> 
227 { 
228 template<typename _Pointer, typename _ForwardIterator> 
229 static void 
230 __ucr(_Pointer, _Pointer, _ForwardIterator) { } 
231 }; 
232 
233 // Constructs objects in the range [first, last). 
234 // Note that while these new objects will take valid values, 
235 // their exact value is not defined. In particular they may 
236 // be 'moved from'. 
237 // 
238 // While *__seed may be altered during this algorithm, it will have 
239 // the same value when the algorithm finishes, unless one of the 
240 // constructions throws. 
241 // 
242 // Requirements: _Pointer::value_type(_Tp&&) is valid. 
243 template<typename _Pointer, typename _ForwardIterator> 
244 inline void 
245 __uninitialized_construct_buf(_Pointer __first, _Pointer __last, 
246 _ForwardIterator __seed) 
247 { 
248 typedef typename std::iterator_traits<_Pointer>::value_type 
249 _ValueType; 
250 
251 std::__uninitialized_construct_buf_dispatch< 
252 __has_trivial_constructor(_ValueType)>:: 
253 __ucr(__first, __last, __seed); 
254 } 
255 
256 template<typename _ForwardIterator, typename _Tp> 
257 _Temporary_buffer<_ForwardIterator, _Tp>:: 
258 _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) 
259 : _M_original_len(__original_len), _M_len(0), _M_buffer(0) 
260 { 
261 std::pair<pointer, size_type> __p( 
262 std::get_temporary_buffer<value_type>(_M_original_len)); 
263 
264 if (__p.first) 
265 { 
266 __try 
267 { 
268 std::__uninitialized_construct_buf(__p.first, __p.first + __p.second, 
269 __seed); 
270 _M_buffer = __p.first; 
271 _M_len = __p.second; 
272 } 
273 __catch(...) 
274 { 
275 std::__detail::__return_temporary_buffer(__p.first, __p.second); 
276 __throw_exception_again; 
277 } 
278 } 
279 } 
280 
281_GLIBCXX_END_NAMESPACE_VERSION 
282} // namespace 
283 
284#endif /* _STL_TEMPBUF_H */ 
285