Warning, /include/c++/v1/__cxx03/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___CXX03_EXPERIMENTAL_MEMORY
0011 #define _LIBCPP___CXX03_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 #include <__cxx03/__functional/hash.h>
0053 #include <__cxx03/__functional/operations.h>
0054 #include <__cxx03/__type_traits/add_lvalue_reference.h>
0055 #include <__cxx03/__type_traits/add_pointer.h>
0056 #include <__cxx03/__type_traits/common_type.h>
0057 #include <__cxx03/__type_traits/enable_if.h>
0058 #include <__cxx03/__type_traits/is_convertible.h>
0059 #include <__cxx03/cstddef>
0060 #include <__cxx03/experimental/__config>
0061
0062 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
0063 # pragma GCC system_header
0064 #endif
0065
0066 #ifdef _LIBCPP_ENABLE_EXPERIMENTAL
0067
0068 _LIBCPP_BEGIN_NAMESPACE_LFTS_V2
0069
0070 # if _LIBCPP_STD_VER >= 17
0071
0072 template <class _Wp>
0073 class observer_ptr {
0074 public:
0075 using element_type = _Wp;
0076
0077 // constructors
0078 _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr() noexcept : __ptr_(nullptr) {}
0079 _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr(nullptr_t) noexcept : __ptr_(nullptr) {}
0080 _LIBCPP_HIDE_FROM_ABI constexpr explicit observer_ptr(element_type* __p) noexcept : __ptr_(__p) {}
0081
0082 template <class _W2, __enable_if_t<is_convertible<_W2*, _Wp*>::value, int> = 0>
0083 _LIBCPP_HIDE_FROM_ABI constexpr observer_ptr(observer_ptr<_W2> __other) noexcept : __ptr_(__other.get()) {}
0084
0085 // observers
0086 _LIBCPP_HIDE_FROM_ABI constexpr element_type* get() const noexcept { return __ptr_; }
0087 _LIBCPP_HIDE_FROM_ABI constexpr add_lvalue_reference_t<_Wp> operator*() const { return *__ptr_; }
0088 _LIBCPP_HIDE_FROM_ABI constexpr element_type* operator->() const noexcept { return __ptr_; }
0089 _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __ptr_ != nullptr; }
0090
0091 // conversions
0092 _LIBCPP_HIDE_FROM_ABI constexpr explicit operator element_type*() const noexcept { return __ptr_; }
0093
0094 // modifiers
0095 _LIBCPP_HIDE_FROM_ABI constexpr void reset(element_type* __p = nullptr) noexcept { __ptr_ = __p; }
0096 _LIBCPP_HIDE_FROM_ABI constexpr void swap(observer_ptr& __other) noexcept {
0097 observer_ptr __tmp = __other;
0098 __other = *this;
0099 *this = __tmp;
0100 }
0101 _LIBCPP_HIDE_FROM_ABI constexpr element_type* release() noexcept {
0102 observer_ptr __p;
0103 __p.swap(*this);
0104 return __p.get();
0105 }
0106
0107 private:
0108 element_type* __ptr_;
0109 };
0110
0111 // specializations
0112
0113 template <class _Wp>
0114 _LIBCPP_HIDE_FROM_ABI constexpr void swap(observer_ptr<_Wp>& __a, observer_ptr<_Wp>& __b) noexcept {
0115 __a.swap(__b);
0116 }
0117
0118 template <class _Wp>
0119 _LIBCPP_HIDE_FROM_ABI observer_ptr<_Wp> make_observer(_Wp* __ptr) noexcept {
0120 return observer_ptr<_Wp>{__ptr};
0121 }
0122
0123 template <class _W1, class _W2>
0124 _LIBCPP_HIDE_FROM_ABI bool operator==(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0125 return __a.get() == __b.get();
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 == __b);
0131 }
0132
0133 template <class _Wp>
0134 _LIBCPP_HIDE_FROM_ABI bool operator==(observer_ptr<_Wp> __p, nullptr_t) {
0135 return !__p;
0136 }
0137
0138 template <class _Wp>
0139 _LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, observer_ptr<_Wp> __p) {
0140 return !__p;
0141 }
0142
0143 template <class _Wp>
0144 _LIBCPP_HIDE_FROM_ABI bool operator!=(observer_ptr<_Wp> __p, nullptr_t) {
0145 return (bool)__p;
0146 }
0147
0148 template <class _Wp>
0149 _LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, observer_ptr<_Wp> __p) {
0150 return (bool)__p;
0151 }
0152
0153 template <class _W1, class _W2>
0154 _LIBCPP_HIDE_FROM_ABI bool operator<(observer_ptr<_W1> __a, observer_ptr<_W2> __b) {
0155 return std::less<typename std::common_type<_W1*, _W2*>::type>()(__a.get(), __b.get());
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 __b < __a;
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 !(__a > __b);
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 # endif // _LIBCPP_STD_VER >= 17
0174
0175 _LIBCPP_END_NAMESPACE_LFTS_V2
0176
0177 _LIBCPP_BEGIN_NAMESPACE_STD
0178
0179 // hash
0180
0181 # if _LIBCPP_STD_VER >= 17
0182 template <class _Tp>
0183 struct hash<experimental::observer_ptr<_Tp>> {
0184 _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::observer_ptr<_Tp>& __ptr) const noexcept {
0185 return hash<_Tp*>()(__ptr.get());
0186 }
0187 };
0188 # endif // _LIBCPP_STD_VER >= 17
0189
0190 _LIBCPP_END_NAMESPACE_STD
0191
0192 #endif // _LIBCPP_ENABLE_EXPERIMENTAL
0193
0194 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
0195 # include <__cxx03/limits>
0196 #endif
0197
0198 #endif /* _LIBCPP___CXX03_EXPERIMENTAL_MEMORY */
