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