Warning, /include/c++/v1/experimental/memory is written in an unsupported language. File is not indexed.
0001 // -*- C++ -*-
0002 //===----------------------------------------------------------------------===//
0003 //
0004 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
0005 // See https://llvm.org/LICENSE.txt for license information.
0006 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
0007 //
0008 //===----------------------------------------------------------------------===//
0009
0010 #ifndef _LIBCPP_EXPERIMENTAL_MEMORY
0011 #define _LIBCPP_EXPERIMENTAL_MEMORY
0012
0013 /*
0014 experimental/memory synopsis
0015
0016 namespace std::experimental::inline fundamentals_v2 {
0017
0018 template <class W> class observer_ptr {
0019 public:
0020 using element_type = W;
0021 using pointer = add_pointer_t<W>; // exposition-only
0022 using reference = add_lvalue_reference_t<W>; // exposition-only
0023
0024 // default ctor
0025 constexpr observer_ptr() noexcept;
0026
0027 // pointer-accepting ctors
0028 constexpr observer_ptr(nullptr_t) noexcept;
0029 constexpr explicit observer_ptr(pointer) noexcept;
0030
0031 // copying ctors (in addition to compiler-generated copy ctor)
0032 template <class W2> constexpr observer_ptr(observer_ptr<W2>) noexcept;
0033
0034 // observers
0035 constexpr pointer get() const noexcept;
0036 constexpr reference operator*() const;
0037 constexpr pointer operator->() const noexcept;
0038 constexpr explicit operator bool() const noexcept;
0039
0040 // conversions
0041 constexpr explicit operator pointer() const noexcept;
0042
0043 // modifiers
0044 constexpr pointer release() noexcept;
0045 constexpr void reset(pointer = nullptr) noexcept;
0046 constexpr void swap(observer_ptr&) noexcept;
0047 };
0048
0049 }
0050 */
0051
0052 #if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
0053 # include <__cxx03/experimental/memory>
0054 #else
0055 # include <__config>
0056 # include <__cstddef/nullptr_t.h>
0057 # include <__cstddef/size_t.h>
0058 # include <__functional/hash.h>
0059 # include <__functional/operations.h>
0060 # include <__type_traits/add_lvalue_reference.h>
0061 # include <__type_traits/add_pointer.h>
0062 # include <__type_traits/common_type.h>
0063 # include <__type_traits/enable_if.h>
0064 # include <__type_traits/is_convertible.h>
0065 # include <version>
0066
0067 # if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
0068 # pragma GCC system_header
0069 # endif
0070
0071 # ifdef _LIBCPP_ENABLE_EXPERIMENTAL
0072
0073 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
0074
0075 # if _LIBCPP_STD_VER >= 17
0076
0077 template <class _Wp>
0078 class observer_ptr {
0079 public:
0080 using element_type = _Wp;
0081
0082 // constructors
0083 _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr() noexcept : __ptr_(nullptr) {}
0084 _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr(nullptr_t) noexcept : __ptr_(nullptr) {}
0085 _LIBCPP_HIDE_FROM_ABI constexpr explicit observer_ptr(element_type* __p) noexcept : __ptr_(__p) {}
0086
0087 template <class _W2, __enable_if_t<is_convertible<_W2*, _Wp*>::value, int> = 0>
0088 _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr(observer_ptr<_W2> __other) noexcept : __ptr_(__other.get()) {}
0089
0090 // observers
0091 _LIBCPP_HIDE_FROM_ABI constexpr element_type* get() const noexcept { return __ptr_; }
0092 _LIBCPP_HIDE_FROM_ABI constexpr add_lvalue_reference_t<_Wp> operator*() const { return *__ptr_; }
0093 _LIBCPP_HIDE_FROM_ABI constexpr element_type* operator->() const noexcept { return __ptr_; }
0094 _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __ptr_ != nullptr; }
0095
0096 // conversions
0097 _LIBCPP_HIDE_FROM_ABI constexpr explicit operator element_type*() const noexcept { return __ptr_; }
0098
0099 // modifiers
0100 _LIBCPP_HIDE_FROM_ABI constexpr void reset(element_type* __p = nullptr) noexcept { __ptr_ = __p; }
0101 _LIBCPP_HIDE_FROM_ABI constexpr void swap(observer_ptr& __other) noexcept {
0102 observer_ptr __tmp = __other;
0103 __other = *this;
0104 *this = __tmp;
0105 }
0106 _LIBCPP_HIDE_FROM_ABI constexpr element_type* release() noexcept {
0107 observer_ptr __p;
0108 __p.swap(*this);
0109 return __p.get();
0110 }
0111
0112 private:
0113 element_type* __ptr_;
0114 };
0115
0116 // specializations
0117
0118 template <class _Wp>
0119 _LIBCPP_HIDE_FROM_ABI constexpr void swap(observer_ptr<_Wp>& __a, observer_ptr<_Wp>& __b) noexcept {
0120 __a.swap(__b);
0121 }
0122
0123 template <class _Wp>
0124 _LIBCPP_HIDE_FROM_ABI observer_ptr<_Wp> make_observer(_Wp* __ptr) noexcept {
0125 return observer_ptr<_Wp>{__ptr};
0126 }
0127
0128 template <class _W1, class _W2>
0129 _LIBCPP_HIDE_FROM_ABI bool operator==(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0130 return __a.get() == __b.get();
0131 }
0132
0133 template <class _W1, class _W2>
0134 _LIBCPP_HIDE_FROM_ABI bool operator!=(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0135 return !(__a == __b);
0136 }
0137
0138 template <class _Wp>
0139 _LIBCPP_HIDE_FROM_ABI bool operator==(observer_ptr<_Wp> __p, nullptr_t) {
0140 return !__p;
0141 }
0142
0143 template <class _Wp>
0144 _LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, observer_ptr<_Wp> __p) {
0145 return !__p;
0146 }
0147
0148 template <class _Wp>
0149 _LIBCPP_HIDE_FROM_ABI bool operator!=(observer_ptr<_Wp> __p, nullptr_t) {
0150 return (bool)__p;
0151 }
0152
0153 template <class _Wp>
0154 _LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, observer_ptr<_Wp> __p) {
0155 return (bool)__p;
0156 }
0157
0158 template <class _W1, class _W2>
0159 _LIBCPP_HIDE_FROM_ABI bool operator<(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0160 return std::less<typename std::common_type<_W1*, _W2*>::type>()(__a.get(), __b.get());
0161 }
0162
0163 template <class _W1, class _W2>
0164 _LIBCPP_HIDE_FROM_ABI bool operator>(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0165 return __b < __a;
0166 }
0167
0168 template <class _W1, class _W2>
0169 _LIBCPP_HIDE_FROM_ABI bool operator<=(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0170 return !(__a > __b);
0171 }
0172
0173 template <class _W1, class _W2>
0174 _LIBCPP_HIDE_FROM_ABI bool operator>=(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0175 return !(__a < __b);
0176 }
0177
0178 # endif // _LIBCPP_STD_VER >= 17
0179
0180 _LIBCPP_END_NAMESPACE_LFTS_V2
0181
0182 _LIBCPP_BEGIN_NAMESPACE_STD
0183
0184 // hash
0185
0186 # if _LIBCPP_STD_VER >= 17
0187 template <class _Tp>
0188 struct hash<experimental::observer_ptr<_Tp>> {
0189 _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::observer_ptr<_Tp>& __ptr) const noexcept {
0190 return hash<_Tp*>()(__ptr.get());
0191 }
0192 };
0193 # endif // _LIBCPP_STD_VER >= 17
0194
0195 _LIBCPP_END_NAMESPACE_STD
0196
0197 # endif // _LIBCPP_ENABLE_EXPERIMENTAL
0198
0199 # if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
0200 # include <cstddef>
0201 # include <limits>
0202 # endif
0203 #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
0204
0205 #endif /* _LIBCPP_EXPERIMENTAL_MEMORY */
