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