libstdc++
experimental/memory
Go to the documentation of this file.
1 // <experimental/memory> -*- C++ -*-
2 
3 // Copyright (C) 2015-2017 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file experimental/memory
26  * This is a TS C++ Library header.
27  */
28 
29 //
30 // N4336 Working Draft, C++ Extensions for Library Fundamentals, Version 2
31 //
32 
33 #ifndef _GLIBCXX_EXPERIMENTAL_MEMORY
34 #define _GLIBCXX_EXPERIMENTAL_MEMORY 1
35 
36 #pragma GCC system_header
37 
38 #if __cplusplus <= 201103L
39 # include <bits/c++14_warning.h>
40 #else
41 
42 #include <memory>
43 #include <type_traits>
44 #include <utility>
46 #include <bits/functional_hash.h>
47 
48 namespace std _GLIBCXX_VISIBILITY(default)
49 {
50 namespace experimental
51 {
52 inline namespace fundamentals_v2
53 {
54 _GLIBCXX_BEGIN_NAMESPACE_VERSION
55 
56 #define __cpp_lib_experimental_observer_ptr 201411
57 
58  template <typename _Tp>
59  class observer_ptr
60  {
61  public:
62  // publish our template parameter and variations thereof
63  using element_type = _Tp;
64  using __pointer = add_pointer_t<_Tp>; // exposition-only
65  using __reference = add_lvalue_reference_t<_Tp>; // exposition-only
66 
67  // 3.2.2, observer_ptr constructors
68  // default c’tor
69  constexpr observer_ptr() noexcept
70  : __t()
71  { }
72 
73  // pointer-accepting c’tors
74  constexpr observer_ptr(nullptr_t) noexcept
75  : __t()
76  { }
77 
78  constexpr explicit observer_ptr(__pointer __p) noexcept
79  : __t(__p)
80  { }
81 
82  // copying c’tors (in addition to compiler-generated copy c’tor)
83  template <typename _Up,
84  typename = typename enable_if<
85  is_convertible<typename add_pointer<_Up>::type, __pointer
86  >::value
87  >::type>
88  constexpr observer_ptr(observer_ptr<_Up> __p) noexcept
89  : __t(__p.get())
90  {
91  }
92 
93  // 3.2.3, observer_ptr observers
94  constexpr __pointer
95  get() const noexcept
96  {
97  return __t;
98  }
99 
100  constexpr __reference
101  operator*() const
102  {
103  return *get();
104  }
105 
106  constexpr __pointer
107  operator->() const noexcept
108  {
109  return get();
110  }
111 
112  constexpr explicit operator bool() const noexcept
113  {
114  return get() != nullptr;
115  }
116 
117  // 3.2.4, observer_ptr conversions
118  constexpr explicit operator __pointer() const noexcept
119  {
120  return get();
121  }
122 
123  // 3.2.5, observer_ptr modifiers
124  constexpr __pointer
125  release() noexcept
126  {
127  __pointer __tmp = get();
128  reset();
129  return __tmp;
130  }
131 
132  constexpr void
133  reset(__pointer __p = nullptr) noexcept
134  {
135  __t = __p;
136  }
137 
138  constexpr void
139  swap(observer_ptr& __p) noexcept
140  {
141  std::swap(__t, __p.__t);
142  }
143 
144  private:
145  __pointer __t;
146  }; // observer_ptr<>
147 
148  template<typename _Tp>
149  void
150  swap(observer_ptr<_Tp>& __p1, observer_ptr<_Tp>& __p2) noexcept
151  {
152  __p1.swap(__p2);
153  }
154 
155  template<typename _Tp>
156  observer_ptr<_Tp>
157  make_observer(_Tp* __p) noexcept
158  {
159  return observer_ptr<_Tp>(__p);
160  }
161 
162  template<typename _Tp, typename _Up>
163  bool
164  operator==(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
165  {
166  return __p1.get() == __p2.get();
167  }
168 
169  template<typename _Tp, typename _Up>
170  bool
171  operator!=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
172  {
173  return !(__p1 == __p2);
174  }
175 
176  template<typename _Tp>
177  bool
178  operator==(observer_ptr<_Tp> __p, nullptr_t) noexcept
179  {
180  return !__p;
181  }
182 
183  template<typename _Tp>
184  bool
185  operator==(nullptr_t, observer_ptr<_Tp> __p) noexcept
186  {
187  return !__p;
188  }
189 
190  template<typename _Tp>
191  bool
192  operator!=(observer_ptr<_Tp> __p, nullptr_t) noexcept
193  {
194  return bool(__p);
195  }
196 
197  template<typename _Tp>
198  bool
199  operator!=(nullptr_t, observer_ptr<_Tp> __p) noexcept
200  {
201  return bool(__p);
202  }
203 
204  template<typename _Tp, typename _Up>
205  bool
206  operator<(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
207  {
209  typename add_pointer<_Up>::type
210  >::type
211  >{}(__p1.get(), __p2.get());
212  }
213 
214  template<typename _Tp, typename _Up>
215  bool
216  operator>(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
217  {
218  return __p2 < __p1;
219  }
220 
221  template<typename _Tp, typename _Up>
222  bool
223  operator<=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
224  {
225  return !(__p2 < __p1);
226  }
227 
228  template<typename _Tp, typename _Up>
229  bool
230  operator>=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
231  {
232  return !(__p1 < __p2);
233  }
234 
235 _GLIBCXX_END_NAMESPACE_VERSION
236 } // namespace fundamentals_v2
237 } // namespace experimental
238 
239 template <typename _Tp>
240  struct hash<experimental::observer_ptr<_Tp>>
241  {
242  using result_type = size_t;
243  using argument_type = experimental::observer_ptr<_Tp>;
244 
245  size_t
246  operator()(const experimental::observer_ptr<_Tp>& __t) const
247  noexcept(noexcept(hash<typename add_pointer<_Tp>::type> {}(__t.get())))
248  {
249  return hash<typename add_pointer<_Tp>::type> {}(__t.get());
250  }
251  };
252 
253 } // namespace std
254 
255 #endif // __cplusplus <= 201103L
256 
257 #endif // _GLIBCXX_EXPERIMENTAL_MEMORY
ISO C++ entities toplevel namespace is std.
complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition: complex:386
One of the comparison functors.
Definition: stl_function.h:340