libcxx/modules/std/memory.inc

   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
  10 export 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   using std::get_deleter;
 160
 161   // [util.smartptr.shared.io], shared_ptr I/O
 162
 163   // [util.smartptr.weak], class template weak_ptr
 164   using std::weak_ptr;
 165
 166   // [util.smartptr.weak.spec], weak_ptr specialized algorithms
 167
 168   // [util.smartptr.ownerless], class template owner_less
 169   using std::owner_less;
 170
 171   // [util.smartptr.enab], class template enable_shared_from_this
 172   using std::enable_shared_from_this;
 173
 174   // [util.smartptr.hash], hash support
 175   using std::hash;
 176
 177   // [util.smartptr.atomic], atomic smart pointers
 178   // using std::atomic;
 179
 180   // [out.ptr.t], class template out_ptr_t
 181   //  using std::out_ptr_t;
 182
 183   // [out.ptr], function template out_ptr
 184   //  using std::out_ptr;
 185
 186   // [inout.ptr.t], class template inout_ptr_t
 187   //  using std::inout_ptr_t;
 188
 189   // [inout.ptr], function template inout_ptr
 190   //  using std::inout_ptr;
 191
 192 #ifndef _LIBCPP_HAS_NO_THREADS
 193   // [depr.util.smartptr.shared.atomic]
 194   using std::atomic_is_lock_free;
 195
 196   using std::atomic_load;
 197   using std::atomic_load_explicit;
 198
 199   using std::atomic_store;
 200   using std::atomic_store_explicit;
 201
 202   using std::atomic_exchange;
 203   using std::atomic_exchange_explicit;
 204
 205   using std::atomic_compare_exchange_strong;
 206   using std::atomic_compare_exchange_strong_explicit;
 207   using std::atomic_compare_exchange_weak;
 208   using std::atomic_compare_exchange_weak_explicit;
 209 #endif // _LIBCPP_HAS_NO_THREADS
 210 } // namespace std