1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10export namespace std {
11  // [pointer.traits], pointer traits
12  using std::pointer_traits;
13
14  // [pointer.conversion], pointer conversion
15  using std::to_address;
16
17  // [ptr.align], pointer alignment
18  using std::align;
19  using std::assume_aligned;
20
21  // [obj.lifetime], explicit lifetime management
22  //  using std::start_lifetime_as;
23  //  using std::start_lifetime_as_array;
24
25  // [allocator.tag], allocator argument tag
26  using std::allocator_arg;
27  using std::allocator_arg_t;
28
29  // [allocator.uses], uses_allocator
30  using std::uses_allocator;
31
32  // [allocator.uses.trait], uses_allocator
33  using std::uses_allocator_v;
34
35  // [allocator.uses.construction], uses-allocator construction
36  using std::uses_allocator_construction_args;
37
38  using std::make_obj_using_allocator;
39  using std::uninitialized_construct_using_allocator;
40
41  // [allocator.traits], allocator traits
42  using std::allocator_traits;
43
44#if _LIBCPP_STD_VER >= 23
45  using std::allocation_result;
46
47  using std::allocate_at_least;
48#endif
49
50  // [default.allocator], the default allocator
51  using std::allocator;
52  using std::operator==;
53
54  // [specialized.addressof], addressof
55  using std::addressof;
56
57  // [specialized.algorithms], specialized algorithms
58  // [special.mem.concepts], special memory concepts
59
60  using std::uninitialized_default_construct;
61  using std::uninitialized_default_construct_n;
62
63  namespace ranges {
64    using std::ranges::uninitialized_default_construct;
65    using std::ranges::uninitialized_default_construct_n;
66  } // namespace ranges
67
68  using std::uninitialized_value_construct;
69  using std::uninitialized_value_construct_n;
70
71  namespace ranges {
72    using std::ranges::uninitialized_value_construct;
73    using std::ranges::uninitialized_value_construct_n;
74  } // namespace ranges
75
76  using std::uninitialized_copy;
77  using std::uninitialized_copy_n;
78
79  namespace ranges {
80    using std::ranges::uninitialized_copy;
81    using std::ranges::uninitialized_copy_result;
82
83    using std::ranges::uninitialized_copy_n;
84    using std::ranges::uninitialized_copy_n_result;
85  } // namespace ranges
86
87  using std::uninitialized_move;
88  using std::uninitialized_move_n;
89
90  namespace ranges {
91    using std::ranges::uninitialized_move;
92    using std::ranges::uninitialized_move_result;
93
94    using std::ranges::uninitialized_move_n;
95    using std::ranges::uninitialized_move_n_result;
96  } // namespace ranges
97
98  using std::uninitialized_fill;
99  using std::uninitialized_fill_n;
100
101  namespace ranges {
102    using std::ranges::uninitialized_fill;
103    using std::ranges::uninitialized_fill_n;
104  } // namespace ranges
105
106  // [specialized.construct], construct_at
107  using std::construct_at;
108
109  namespace ranges {
110    using std::ranges::construct_at;
111  }
112  // [specialized.destroy], destroy
113  using std::destroy;
114  using std::destroy_at;
115  using std::destroy_n;
116
117  namespace ranges {
118    using std::ranges::destroy;
119    using std::ranges::destroy_at;
120    using std::ranges::destroy_n;
121  } // namespace ranges
122
123  // [unique.ptr], class template unique_ptr
124  using std::default_delete;
125  using std::unique_ptr;
126
127  using std::make_unique;
128  using std::make_unique_for_overwrite;
129
130  using std::operator<;
131  using std::operator>;
132  using std::operator<=;
133  using std::operator>=;
134  using std::operator<=>;
135
136  using std::operator<<;
137
138  // [util.smartptr.weak.bad], class bad_weak_ptr
139  using std::bad_weak_ptr;
140
141  // [util.smartptr.shared], class template shared_ptr
142  using std::shared_ptr;
143
144  // [util.smartptr.shared.create], shared_ptr creation
145  using std::allocate_shared;
146  using std::allocate_shared_for_overwrite;
147  using std::make_shared;
148  using std::make_shared_for_overwrite;
149
150  // [util.smartptr.shared.spec], shared_ptr specialized algorithms
151  using std::swap;
152
153  // [util.smartptr.shared.cast], shared_ptr casts
154  using std::const_pointer_cast;
155  using std::dynamic_pointer_cast;
156  using std::reinterpret_pointer_cast;
157  using std::static_pointer_cast;
158
159#ifndef _LIBCPP_HAS_NO_RTTI
160  using std::get_deleter;
161#endif // _LIBCPP_HAS_NO_RTTI
162
163  // [util.smartptr.shared.io], shared_ptr I/O
164
165  // [util.smartptr.weak], class template weak_ptr
166  using std::weak_ptr;
167
168  // [util.smartptr.weak.spec], weak_ptr specialized algorithms
169
170  // [util.smartptr.ownerless], class template owner_less
171  using std::owner_less;
172
173  // [util.smartptr.enab], class template enable_shared_from_this
174  using std::enable_shared_from_this;
175
176  // [util.smartptr.hash], hash support
177  using std::hash;
178
179  // [util.smartptr.atomic], atomic smart pointers
180  // using std::atomic;
181
182  // [out.ptr.t], class template out_ptr_t
183  //  using std::out_ptr_t;
184
185  // [out.ptr], function template out_ptr
186  //  using std::out_ptr;
187
188  // [inout.ptr.t], class template inout_ptr_t
189  //  using std::inout_ptr_t;
190
191  // [inout.ptr], function template inout_ptr
192  //  using std::inout_ptr;
193
194#ifndef _LIBCPP_HAS_NO_THREADS
195  // [depr.util.smartptr.shared.atomic]
196  using std::atomic_is_lock_free;
197
198  using std::atomic_load;
199  using std::atomic_load_explicit;
200
201  using std::atomic_store;
202  using std::atomic_store_explicit;
203
204  using std::atomic_exchange;
205  using std::atomic_exchange_explicit;
206
207  using std::atomic_compare_exchange_strong;
208  using std::atomic_compare_exchange_strong_explicit;
209  using std::atomic_compare_exchange_weak;
210  using std::atomic_compare_exchange_weak_explicit;
211#endif // _LIBCPP_HAS_NO_THREADS
212} // namespace std
213