11.2.0/bits/stl_construct.h

// nonstandard construct and destroy functions -*- C++ -*-

// Copyright (C) 2001-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 *
 * Copyright (c) 1996,1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 */

/** @file bits/stl_construct.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{memory}
 */

#ifndef _STL_CONSTRUCT_H
#define _STL_CONSTRUCT_H 1

#include <new>
#include <bits/move.h>
#include <bits/stl_iterator_base_types.h> // for iterator_traits
#include <bits/stl_iterator_base_funcs.h> // for advance

/* This file provides the C++17 functions std::destroy_at, std::destroy, and
 * std::destroy_n, and the C++20 function std::construct_at.
 * It also provides std::_Construct, std::_Destroy,and std::_Destroy_n functions
 * which are defined in all standard modes and so can be used in C++98-14 code.
 * The _Destroy functions will dispatch to destroy_at during constant
 * evaluation, because calls to that function are intercepted by the compiler
 * to allow use in constant expressions.
 */

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

#if __cplusplus >= 201703L
  template <typename _Tp>
    _GLIBCXX20_CONSTEXPR inline void
    destroy_at(_Tp* __location)
    {
      if constexpr (__cplusplus > 201703L && is_array_v<_Tp>)
        {
          for (auto& __x : *__location)
            std::destroy_at(std::__addressof(__x));
        }
      else
        __location->~_Tp();
    }

#if __cplusplus > 201703L
  template<typename _Tp, typename... _Args>
    constexpr auto
    construct_at(_Tp* __location, _Args&&... __args)
    noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...)))
    -> decltype(::new((void*)0) _Tp(std::declval<_Args>()...))
    { return ::new((void*)__location) _Tp(std::forward<_Args>(__args)...); }
#endif // C++20
#endif// C++17

  /**
   * Constructs an object in existing memory by invoking an allocated
   * object's constructor with an initializer.
   */
#if __cplusplus >= 201103L
  template<typename _Tp, typename... _Args>
    inline void
    _Construct(_Tp* __p, _Args&&... __args)
    { ::new(static_cast<void*>(__p)) _Tp(std::forward<_Args>(__args)...); }
#else
  template<typename _T1, typename _T2>
    inline void
    _Construct(_T1* __p, const _T2& __value)
    {
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 402. wrong new expression in [some_]allocator::construct
      ::new(static_cast<void*>(__p)) _T1(__value);
    }
#endif

  template<typename _T1>
    inline void
    _Construct_novalue(_T1* __p)
    { ::new(static_cast<void*>(__p)) _T1; }

  template<typename _ForwardIterator>
    _GLIBCXX20_CONSTEXPR void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last);

  /**
   * Destroy the object pointed to by a pointer type.
   */
  template<typename _Tp>
    _GLIBCXX14_CONSTEXPR inline void
    _Destroy(_Tp* __pointer)
    {
#if __cplusplus > 201703L
      std::destroy_at(__pointer);
#else
      __pointer->~_Tp();
#endif
    }

  template<bool>
    struct _Destroy_aux
    {
      template<typename _ForwardIterator>
        static _GLIBCXX20_CONSTEXPR void
        __destroy(_ForwardIterator __first, _ForwardIterator __last)
        {
          for (; __first != __last; ++__first)
            std::_Destroy(std::__addressof(*__first));
        }
    };

  template<>
    struct _Destroy_aux<true>
    {
      template<typename _ForwardIterator>
        static void
        __destroy(_ForwardIterator, _ForwardIterator) { }
    };

  /**
   * Destroy a range of objects.  If the value_type of the object has
   * a trivial destructor, the compiler should optimize all of this
   * away, otherwise the objects' destructors must be invoked.
   */
  template<typename _ForwardIterator>
    _GLIBCXX20_CONSTEXPR inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;
#if __cplusplus >= 201103L
      // A deleted destructor is trivial, this ensures we reject such types:
      static_assert(is_destructible<_Value_type>::value,
                    "value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
      if (std::is_constant_evaluated())
        return _Destroy_aux<false>::__destroy(__first, __last);
#endif
      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
        __destroy(__first, __last);
    }

  template<bool>
    struct _Destroy_n_aux
    {
      template<typename _ForwardIterator, typename _Size>
        static _GLIBCXX20_CONSTEXPR _ForwardIterator
        __destroy_n(_ForwardIterator __first, _Size __count)
        {
          for (; __count > 0; (void)++__first, --__count)
            std::_Destroy(std::__addressof(*__first));
          return __first;
        }
    };

  template<>
    struct _Destroy_n_aux<true>
    {
      template<typename _ForwardIterator, typename _Size>
        static _ForwardIterator
        __destroy_n(_ForwardIterator __first, _Size __count)
        {
          std::advance(__first, __count);
          return __first;
        }
    };

  /**
   * Destroy a range of objects.  If the value_type of the object has
   * a trivial destructor, the compiler should optimize all of this
   * away, otherwise the objects' destructors must be invoked.
   */
  template<typename _ForwardIterator, typename _Size>
    _GLIBCXX20_CONSTEXPR inline _ForwardIterator
    _Destroy_n(_ForwardIterator __first, _Size __count)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;
#if __cplusplus >= 201103L
      // A deleted destructor is trivial, this ensures we reject such types:
      static_assert(is_destructible<_Value_type>::value,
                    "value type is destructible");
#endif
#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
      if (std::is_constant_evaluated())
        return _Destroy_n_aux<false>::__destroy_n(__first, __count);
#endif
      return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
        __destroy_n(__first, __count);
    }

#if __cplusplus >= 201703L
  template <typename _ForwardIterator>
    _GLIBCXX20_CONSTEXPR inline void
    destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      std::_Destroy(__first, __last);
    }

  template <typename _ForwardIterator, typename _Size>
    _GLIBCXX20_CONSTEXPR inline _ForwardIterator
    destroy_n(_ForwardIterator __first, _Size __count)
    {
      return std::_Destroy_n(__first, __count);
    }
#endif // C++17

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif /* _STL_CONSTRUCT_H */
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	8521 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	// nonstandard construct and destroy functions -- 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_construct.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_CONSTRUCT_H
57	#define _STL_CONSTRUCT_H 1
58
59	#include <new>
60	#include <bits/move.h>
61	#include <bits/stl_iterator_base_types.h> // for iterator_traits
62	#include <bits/stl_iterator_base_funcs.h> // for advance
63
64	/* This file provides the C++17 functions std::destroy_at, std::destroy, and
65	* std::destroy_n, and the C++20 function std::construct_at.
66	* It also provides std::_Construct, std::_Destroy,and std::_Destroy_n functions
67	* which are defined in all standard modes and so can be used in C++98-14 code.
68	* The _Destroy functions will dispatch to destroy_at during constant
69	* evaluation, because calls to that function are intercepted by the compiler
70	* to allow use in constant expressions.
71	*/
72
73	namespace std _GLIBCXX_VISIBILITY(default)
74	{
75	_GLIBCXX_BEGIN_NAMESPACE_VERSION
76
77	#if __cplusplus >= 201703L
78	template <typename _Tp>
79	_GLIBCXX20_CONSTEXPR inline void
80	destroy_at(_Tp* __location)
81	{
82	if constexpr (__cplusplus > 201703L && is_array_v<_Tp>)
83	{
84	for (auto& __x : *__location)
85	std::destroy_at(std::__addressof(__x));
86	}
87	else
88	__location->~_Tp();
89	}
90
91	#if __cplusplus > 201703L
92	template<typename _Tp, typename... _Args>
93	constexpr auto
94	construct_at(_Tp* __location, _Args&&... __args)
95	noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...)))
96	-> decltype(::new((void*)0) _Tp(std::declval<_Args>()...))
97	{ return ::new((void*)__location) _Tp(std::forward<_Args>(__args)...); }
98	#endif // C++20
99	#endif// C++17
100
101	/**
102	* Constructs an object in existing memory by invoking an allocated
103	* object's constructor with an initializer.
104	*/
105	#if __cplusplus >= 201103L
106	template<typename _Tp, typename... _Args>
107	inline void
108	_Construct(_Tp* __p, _Args&&... __args)
109	{ ::new(static_cast<void*>(__p)) _Tp(std::forward<_Args>(__args)...); }
110	#else
111	template<typename _T1, typename _T2>
112	inline void
113	_Construct(_T1* __p, const _T2& __value)
114	{
115	// _GLIBCXX_RESOLVE_LIB_DEFECTS
116	// 402. wrong new expression in [some_]allocator::construct
117	::new(static_cast<void*>(__p)) _T1(__value);
118	}
119	#endif
120
121	template<typename _T1>
122	inline void
123	_Construct_novalue(_T1* __p)
124	{ ::new(static_cast<void*>(__p)) _T1; }
125
126	template<typename _ForwardIterator>
127	_GLIBCXX20_CONSTEXPR void
128	_Destroy(_ForwardIterator __first, _ForwardIterator __last);
129
130	/**
131	* Destroy the object pointed to by a pointer type.
132	*/
133	template<typename _Tp>
134	_GLIBCXX14_CONSTEXPR inline void
135	_Destroy(_Tp* __pointer)
136	{
137	#if __cplusplus > 201703L
138	std::destroy_at(__pointer);
139	#else
140	__pointer->~_Tp();
141	#endif
142	}
143
144	template<bool>
145	struct _Destroy_aux
146	{
147	template<typename _ForwardIterator>
148	static _GLIBCXX20_CONSTEXPR void
149	__destroy(_ForwardIterator __first, _ForwardIterator __last)
150	{
151	for (; __first != __last; ++__first)
152	std::_Destroy(std::__addressof(*__first));
153	}
154	};
155
156	template<>
157	struct _Destroy_aux<true>
158	{
159	template<typename _ForwardIterator>
160	static void
161	__destroy(_ForwardIterator, _ForwardIterator) { }
162	};
163
164	/**
165	* Destroy a range of objects. If the value_type of the object has
166	* a trivial destructor, the compiler should optimize all of this
167	* away, otherwise the objects' destructors must be invoked.
168	*/
169	template<typename _ForwardIterator>
170	_GLIBCXX20_CONSTEXPR inline void
171	_Destroy(_ForwardIterator __first, _ForwardIterator __last)
172	{
173	typedef typename iterator_traits<_ForwardIterator>::value_type
174	_Value_type;
175	#if __cplusplus >= 201103L
176	// A deleted destructor is trivial, this ensures we reject such types:
177	static_assert(is_destructible<_Value_type>::value,
178	"value type is destructible");
179	#endif
180	#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
181	if (std::is_constant_evaluated())
182	return _Destroy_aux<false>::__destroy(__first, __last);
183	#endif
184	std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
185	__destroy(__first, __last);
186	}
187
188	template<bool>
189	struct _Destroy_n_aux
190	{
191	template<typename _ForwardIterator, typename _Size>
192	static _GLIBCXX20_CONSTEXPR _ForwardIterator
193	__destroy_n(_ForwardIterator __first, _Size __count)
194	{
195	for (; __count > 0; (void)++__first, --__count)
196	std::_Destroy(std::__addressof(*__first));
197	return __first;
198	}
199	};
200
201	template<>
202	struct _Destroy_n_aux<true>
203	{
204	template<typename _ForwardIterator, typename _Size>
205	static _ForwardIterator
206	__destroy_n(_ForwardIterator __first, _Size __count)
207	{
208	std::advance(__first, __count);
209	return __first;
210	}
211	};
212
213	/**
214	* Destroy a range of objects. If the value_type of the object has
215	* a trivial destructor, the compiler should optimize all of this
216	* away, otherwise the objects' destructors must be invoked.
217	*/
218	template<typename _ForwardIterator, typename _Size>
219	_GLIBCXX20_CONSTEXPR inline _ForwardIterator
220	_Destroy_n(_ForwardIterator __first, _Size __count)
221	{
222	typedef typename iterator_traits<_ForwardIterator>::value_type
223	_Value_type;
224	#if __cplusplus >= 201103L
225	// A deleted destructor is trivial, this ensures we reject such types:
226	static_assert(is_destructible<_Value_type>::value,
227	"value type is destructible");
228	#endif
229	#if __cplusplus > 201703L && defined __cpp_lib_is_constant_evaluated
230	if (std::is_constant_evaluated())
231	return _Destroy_n_aux<false>::__destroy_n(__first, __count);
232	#endif
233	return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
234	__destroy_n(__first, __count);
235	}
236
237	#if __cplusplus >= 201703L
238	template <typename _ForwardIterator>
239	_GLIBCXX20_CONSTEXPR inline void
240	destroy(_ForwardIterator __first, _ForwardIterator __last)
241	{
242	std::_Destroy(__first, __last);
243	}
244
245	template <typename _ForwardIterator, typename _Size>
246	_GLIBCXX20_CONSTEXPR inline _ForwardIterator
247	destroy_n(_ForwardIterator __first, _Size __count)
248	{
249	return std::_Destroy_n(__first, __count);
250	}
251	#endif // C++17
252
253	_GLIBCXX_END_NAMESPACE_VERSION
254	} // namespace std
255
256	#endif /* _STL_CONSTRUCT_H */