1// Temporary buffer implementation -*- C++ -*-
2
3// Copyright (C) 2001-2022 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    _GLIBCXX17_DEPRECATED
100    pair<_Tp*, ptrdiff_t>
101    get_temporary_buffer(ptrdiff_t __len) _GLIBCXX_NOEXCEPT
102    {
103      const ptrdiff_t __max =
104	__gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
105      if (__len > __max)
106	__len = __max;
107
108      while (__len > 0)
109	{
110	  _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
111							std::nothrow));
112	  if (__tmp != 0)
113	    return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
114	  __len = __len == 1 ? 0 : ((__len + 1) / 2);
115	}
116      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
117    }
118
119  /**
120   *  @brief The companion to get_temporary_buffer().
121   *  @param  __p  A buffer previously allocated by get_temporary_buffer.
122   *  @return   None.
123   *
124   *  Frees the memory pointed to by __p.
125   */
126  template<typename _Tp>
127    inline void
128    return_temporary_buffer(_Tp* __p)
129    { ::operator delete(__p); }
130
131  /**
132   *  This class is used in two places: stl_algo.h and ext/memory,
133   *  where it is wrapped as the temporary_buffer class.  See
134   *  temporary_buffer docs for more notes.
135   */
136  template<typename _ForwardIterator, typename _Tp>
137    class _Temporary_buffer
138    {
139      // concept requirements
140      __glibcxx_class_requires(_ForwardIterator, _ForwardIteratorConcept)
141
142    public:
143      typedef _Tp         value_type;
144      typedef value_type* pointer;
145      typedef pointer     iterator;
146      typedef ptrdiff_t   size_type;
147
148    protected:
149      size_type  _M_original_len;
150      size_type  _M_len;
151      pointer    _M_buffer;
152
153    public:
154      /// As per Table mumble.
155      size_type
156      size() const
157      { return _M_len; }
158
159      /// Returns the size requested by the constructor; may be >size().
160      size_type
161      requested_size() const
162      { return _M_original_len; }
163
164      /// As per Table mumble.
165      iterator
166      begin()
167      { return _M_buffer; }
168
169      /// As per Table mumble.
170      iterator
171      end()
172      { return _M_buffer + _M_len; }
173
174      /**
175       * Constructs a temporary buffer of a size somewhere between
176       * zero and the given length.
177       */
178      _Temporary_buffer(_ForwardIterator __seed, size_type __original_len);
179
180      ~_Temporary_buffer()
181      {
182	std::_Destroy(_M_buffer, _M_buffer + _M_len);
183	std::__detail::__return_temporary_buffer(_M_buffer, _M_len);
184      }
185
186    private:
187      // Disable copy constructor and assignment operator.
188      _Temporary_buffer(const _Temporary_buffer&);
189
190      void
191      operator=(const _Temporary_buffer&);
192    };
193
194
195  template<bool>
196    struct __uninitialized_construct_buf_dispatch
197    {
198      template<typename _Pointer, typename _ForwardIterator>
199        static void
200        __ucr(_Pointer __first, _Pointer __last,
201	      _ForwardIterator __seed)
202        {
203	  if (__first == __last)
204	    return;
205
206	  _Pointer __cur = __first;
207	  __try
208	    {
209	      std::_Construct(std::__addressof(*__first),
210			      _GLIBCXX_MOVE(*__seed));
211	      _Pointer __prev = __cur;
212	      ++__cur;
213	      for(; __cur != __last; ++__cur, ++__prev)
214		std::_Construct(std::__addressof(*__cur),
215				_GLIBCXX_MOVE(*__prev));
216	      *__seed = _GLIBCXX_MOVE(*__prev);
217	    }
218	  __catch(...)
219	    {
220	      std::_Destroy(__first, __cur);
221	      __throw_exception_again;
222	    }
223	}
224    };
225
226  template<>
227    struct __uninitialized_construct_buf_dispatch<true>
228    {
229      template<typename _Pointer, typename _ForwardIterator>
230        static void
231        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
232    };
233
234  // Constructs objects in the range [first, last).
235  // Note that while these new objects will take valid values,
236  // their exact value is not defined. In particular they may
237  // be 'moved from'.
238  //
239  // While *__seed may be altered during this algorithm, it will have
240  // the same value when the algorithm finishes, unless one of the
241  // constructions throws.
242  //
243  // Requirements: _Pointer::value_type(_Tp&&) is valid.
244  template<typename _Pointer, typename _ForwardIterator>
245    inline void
246    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
247				  _ForwardIterator __seed)
248    {
249      typedef typename std::iterator_traits<_Pointer>::value_type
250	_ValueType;
251
252      std::__uninitialized_construct_buf_dispatch<
253        __has_trivial_constructor(_ValueType)>::
254	  __ucr(__first, __last, __seed);
255    }
256
257#pragma GCC diagnostic push
258#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
259  template<typename _ForwardIterator, typename _Tp>
260    _Temporary_buffer<_ForwardIterator, _Tp>::
261    _Temporary_buffer(_ForwardIterator __seed, size_type __original_len)
262    : _M_original_len(__original_len), _M_len(0), _M_buffer(0)
263    {
264      std::pair<pointer, size_type> __p(
265		std::get_temporary_buffer<value_type>(_M_original_len));
266
267      if (__p.first)
268	{
269	  __try
270	    {
271	      std::__uninitialized_construct_buf(__p.first, __p.first + __p.second,
272						 __seed);
273	      _M_buffer = __p.first;
274	      _M_len = __p.second;
275	    }
276	  __catch(...)
277	    {
278	      std::__detail::__return_temporary_buffer(__p.first, __p.second);
279	      __throw_exception_again;
280	    }
281	}
282    }
283#pragma GCC diagnostic pop
284
285_GLIBCXX_END_NAMESPACE_VERSION
286} // namespace
287
288#endif /* _STL_TEMPBUF_H */
289