Line data Source code
1 : // Temporary buffer implementation -*- C++ -*-
2 :
3 : // Copyright (C) 2001-2013 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 :
62 : namespace std _GLIBCXX_VISIBILITY(default)
63 : {
64 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
65 :
66 : /**
67 : * @brief Allocates a temporary buffer.
68 : * @param __len The number of objects of type Tp.
69 : * @return See full description.
70 : *
71 : * Reinventing the wheel, but this time with prettier spokes!
72 : *
73 : * This function tries to obtain storage for @c __len adjacent Tp
74 : * objects. The objects themselves are not constructed, of course.
75 : * A pair<> is returned containing <em>the buffer s address and
76 : * capacity (in the units of sizeof(_Tp)), or a pair of 0 values if
77 : * no storage can be obtained.</em> Note that the capacity obtained
78 : * may be less than that requested if the memory is unavailable;
79 : * you should compare len with the .second return value.
80 : *
81 : * Provides the nothrow exception guarantee.
82 : */
83 : template<typename _Tp>
84 : pair<_Tp*, ptrdiff_t>
85 582 : get_temporary_buffer(ptrdiff_t __len) _GLIBCXX_NOEXCEPT
86 : {
87 : const ptrdiff_t __max =
88 582 : __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
89 582 : if (__len > __max)
90 0 : __len = __max;
91 :
92 582 : while (__len > 0)
93 : {
94 : _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
95 345 : std::nothrow));
96 345 : if (__tmp != 0)
97 345 : return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
98 0 : __len /= 2;
99 : }
100 237 : return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
101 : }
102 :
103 : /**
104 : * @brief The companion to get_temporary_buffer().
105 : * @param __p A buffer previously allocated by get_temporary_buffer.
106 : * @return None.
107 : *
108 : * Frees the memory pointed to by __p.
109 : */
110 : template<typename _Tp>
111 : inline void
112 : return_temporary_buffer(_Tp* __p)
113 582 : { ::operator delete(__p, std::nothrow); }
114 :
115 :
116 : /**
117 : * This class is used in two places: stl_algo.h and ext/memory,
118 : * where it is wrapped as the temporary_buffer class. See
119 : * temporary_buffer docs for more notes.
120 : */
121 : template<typename _ForwardIterator, typename _Tp>
122 : class _Temporary_buffer
123 : {
124 : // concept requirements
125 : __glibcxx_class_requires(_ForwardIterator, _ForwardIteratorConcept)
126 :
127 : public:
128 : typedef _Tp value_type;
129 : typedef value_type* pointer;
130 : typedef pointer iterator;
131 : typedef ptrdiff_t size_type;
132 :
133 : protected:
134 : size_type _M_original_len;
135 : size_type _M_len;
136 : pointer _M_buffer;
137 :
138 : public:
139 : /// As per Table mumble.
140 : size_type
141 : size() const
142 : { return _M_len; }
143 :
144 : /// Returns the size requested by the constructor; may be >size().
145 : size_type
146 : requested_size() const
147 : { return _M_original_len; }
148 :
149 : /// As per Table mumble.
150 : iterator
151 : begin()
152 : { return _M_buffer; }
153 :
154 : /// As per Table mumble.
155 : iterator
156 : end()
157 : { return _M_buffer + _M_len; }
158 :
159 : /**
160 : * Constructs a temporary buffer of a size somewhere between
161 : * zero and the size of the given range.
162 : */
163 : _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
164 :
165 582 : ~_Temporary_buffer()
166 : {
167 582 : std::_Destroy(_M_buffer, _M_buffer + _M_len);
168 582 : std::return_temporary_buffer(_M_buffer);
169 582 : }
170 :
171 : private:
172 : // Disable copy constructor and assignment operator.
173 : _Temporary_buffer(const _Temporary_buffer&);
174 :
175 : void
176 : operator=(const _Temporary_buffer&);
177 : };
178 :
179 :
180 : template<bool>
181 : struct __uninitialized_construct_buf_dispatch
182 : {
183 : template<typename _Pointer, typename _ForwardIterator>
184 : static void
185 345 : __ucr(_Pointer __first, _Pointer __last,
186 : _ForwardIterator __seed)
187 : {
188 345 : if(__first == __last)
189 345 : return;
190 :
191 345 : _Pointer __cur = __first;
192 : __try
193 : {
194 : std::_Construct(std::__addressof(*__first),
195 345 : _GLIBCXX_MOVE(*__seed));
196 345 : _Pointer __prev = __cur;
197 345 : ++__cur;
198 2374 : for(; __cur != __last; ++__cur, ++__prev)
199 : std::_Construct(std::__addressof(*__cur),
200 2029 : _GLIBCXX_MOVE(*__prev));
201 345 : *__seed = _GLIBCXX_MOVE(*__prev);
202 : }
203 : __catch(...)
204 : {
205 : std::_Destroy(__first, __cur);
206 : __throw_exception_again;
207 : }
208 : }
209 : };
210 :
211 : template<>
212 : struct __uninitialized_construct_buf_dispatch<true>
213 : {
214 : template<typename _Pointer, typename _ForwardIterator>
215 : static void
216 : __ucr(_Pointer, _Pointer, _ForwardIterator) { }
217 : };
218 :
219 : // Constructs objects in the range [first, last).
220 : // Note that while these new objects will take valid values,
221 : // their exact value is not defined. In particular they may
222 : // be 'moved from'.
223 : //
224 : // While *__seed may be altered during this algorithm, it will have
225 : // the same value when the algorithm finishes, unless one of the
226 : // constructions throws.
227 : //
228 : // Requirements: _Pointer::value_type(_Tp&&) is valid.
229 : template<typename _Pointer, typename _ForwardIterator>
230 : inline void
231 : __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
232 : _ForwardIterator __seed)
233 : {
234 : typedef typename std::iterator_traits<_Pointer>::value_type
235 : _ValueType;
236 :
237 345 : std::__uninitialized_construct_buf_dispatch<
238 : __has_trivial_constructor(_ValueType)>::
239 : __ucr(__first, __last, __seed);
240 : }
241 :
242 : template<typename _ForwardIterator, typename _Tp>
243 582 : _Temporary_buffer<_ForwardIterator, _Tp>::
244 : _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
245 : : _M_original_len(std::distance(__first, __last)),
246 582 : _M_len(0), _M_buffer(0)
247 : {
248 : __try
249 : {
250 : std::pair<pointer, size_type> __p(std::get_temporary_buffer<
251 582 : value_type>(_M_original_len));
252 582 : _M_buffer = __p.first;
253 582 : _M_len = __p.second;
254 582 : if (_M_buffer)
255 : std::__uninitialized_construct_buf(_M_buffer, _M_buffer + _M_len,
256 345 : __first);
257 : }
258 : __catch(...)
259 : {
260 : std::return_temporary_buffer(_M_buffer);
261 : _M_buffer = 0;
262 : _M_len = 0;
263 : __throw_exception_again;
264 : }
265 582 : }
266 :
267 : _GLIBCXX_END_NAMESPACE_VERSION
268 : } // namespace
269 :
270 : #endif /* _STL_TEMPBUF_H */
271 :
|
