1// <experimental/propagate_const> -*- C++ -*-
2
3// Copyright (C) 2015-2019 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/propagate_const
26 *  This is a TS C++ Library header.
27 */
28
29#ifndef _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST
30#define _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST 1
31
32#pragma GCC system_header
33
34#if __cplusplus >= 201402L
35
36#include <type_traits>
37#include <bits/functional_hash.h>
38#include <bits/move.h>
39#include <bits/stl_function.h>
40#include <experimental/bits/lfts_config.h>
41
42namespace std _GLIBCXX_VISIBILITY(default)
43{
44_GLIBCXX_BEGIN_NAMESPACE_VERSION
45
46namespace experimental
47{
48inline namespace fundamentals_v2
49{
50  /**
51   * @defgroup propagate_const Const-propagating wrapper
52   * @ingroup experimental
53   *
54   * A const-propagating wrapper that propagates const to pointer-like members,
55   * as described in n4388 "A Proposal to Add a Const-Propagating Wrapper
56   * to the Standard Library".
57   *
58   * @{
59   */
60
61/// Const-propagating wrapper.
62  template <typename _Tp>
63    class propagate_const
64    {
65    public:
66      typedef remove_reference_t<decltype(*std::declval<_Tp&>())> element_type;
67
68    private:
69      template <typename _Up>
70	struct __is_propagate_const : false_type
71	{ };
72
73      template <typename _Up>
74	struct __is_propagate_const<propagate_const<_Up>> : true_type
75	{ };
76
77      template <typename _Up>
78	friend constexpr const _Up&
79	get_underlying(const propagate_const<_Up>& __pt) noexcept;
80      template <typename _Up>
81	friend constexpr _Up&
82	get_underlying(propagate_const<_Up>& __pt) noexcept;
83
84      template <typename _Up>
85	static constexpr element_type*
86	__to_raw_pointer(_Up* __u)
87	{ return __u; }
88
89      template <typename _Up>
90	static constexpr element_type*
91	__to_raw_pointer(_Up& __u)
92	{ return __u.get(); }
93
94      template <typename _Up>
95	static constexpr const element_type*
96	__to_raw_pointer(const _Up* __u)
97	{ return __u; }
98
99      template <typename _Up>
100	static constexpr const element_type*
101	__to_raw_pointer(const _Up& __u)
102	{ return __u.get(); }
103
104    public:
105      static_assert(__and_<is_object<typename remove_pointer<_Tp>::type>,
106			   __not_<is_array<_Tp>>,
107			   __or_<is_class<_Tp>, is_pointer<_Tp>>>::value,
108		    "propagate_const requires a class or a pointer to an"
109		    " object type");
110
111      // [propagate_const.ctor], constructors
112      constexpr propagate_const() = default;
113      propagate_const(const propagate_const& __p) = delete;
114      constexpr propagate_const(propagate_const&& __p) = default;
115      template <typename _Up, typename
116		enable_if<__and_<is_constructible<_Tp, _Up&&>,
117				 is_convertible<_Up&&, _Tp>>::value, bool
118			  >::type=true>
119      constexpr propagate_const(propagate_const<_Up>&& __pu)
120	: _M_t(std::move(get_underlying(__pu)))
121      {}
122      template <typename _Up, typename
123		enable_if<__and_<is_constructible<_Tp, _Up&&>,
124				 __not_<is_convertible<_Up&&, _Tp>>>::value,
125			  bool>::type=false>
126      constexpr explicit propagate_const(propagate_const<_Up>&& __pu)
127	: _M_t(std::move(get_underlying(__pu)))
128      {}
129      template <typename _Up, typename
130		enable_if<__and_<is_constructible<_Tp, _Up&&>,
131				 is_convertible<_Up&&, _Tp>,
132				 __not_<__is_propagate_const<
133					  typename decay<_Up>::type>>
134				 >::value, bool>::type=true>
135      constexpr propagate_const(_Up&& __u)
136	: _M_t(std::forward<_Up>(__u))
137      {}
138      template <typename _Up, typename
139		enable_if<__and_<is_constructible<_Tp, _Up&&>,
140				 __not_<is_convertible<_Up&&, _Tp>>,
141				 __not_<__is_propagate_const<
142					  typename decay<_Up>::type>>
143				 >::value, bool>::type=false>
144      constexpr explicit propagate_const(_Up&& __u)
145	: _M_t(std::forward<_Up>(__u))
146      {}
147
148      // [propagate_const.assignment], assignment
149      propagate_const& operator=(const propagate_const& __p) = delete;
150      constexpr propagate_const& operator=(propagate_const&& __p) = default;
151
152      template <typename _Up, typename =
153		typename enable_if<is_convertible<_Up&&, _Tp>::value>::type>
154      constexpr propagate_const& operator=(propagate_const<_Up>&& __pu)
155      {
156	_M_t = std::move(get_underlying(__pu));
157	return *this;
158      }
159
160      template <typename _Up, typename =
161		typename enable_if<__and_<is_convertible<_Up&&, _Tp>,
162					  __not_<__is_propagate_const<
163						   typename decay<_Up>::type>>
164					  >::value>::type>
165      constexpr propagate_const& operator=(_Up&& __u)
166      {
167	_M_t = std::forward<_Up>(__u);
168	return *this;
169      }
170
171      // [propagate_const.const_observers], const observers
172      explicit constexpr operator bool() const
173      {
174	return bool(_M_t);
175      }
176
177      constexpr const element_type* operator->() const
178      {
179	return get();
180      }
181
182      template <typename _Up = _Tp,
183		typename enable_if<__or_<is_pointer<_Up>,
184					 is_convertible<_Up,
185							const element_type*>
186					 >::value, bool>::type = true>
187      constexpr operator const element_type*() const
188      {
189	return get();
190      }
191
192      constexpr const element_type& operator*() const
193      {
194	return *get();
195      }
196
197      constexpr const element_type* get() const
198      {
199	return __to_raw_pointer(_M_t);
200      }
201
202      // [propagate_const.non_const_observers], non-const observers
203      constexpr element_type* operator->()
204      {
205	return get();
206      }
207
208      template <typename _Up = _Tp,
209		typename enable_if<__or_<is_pointer<_Up>,
210					 is_convertible<_Up,
211						        const element_type*>
212					 >::value, bool>::type = true>
213      constexpr operator element_type*()
214      {
215	return get();
216      }
217
218      constexpr element_type& operator*()
219      {
220	return *get();
221      }
222
223      constexpr element_type* get()
224      {
225	return __to_raw_pointer(_M_t);
226      }
227
228      // [propagate_const.modifiers], modifiers
229      constexpr void
230      swap(propagate_const& __pt) noexcept(__is_nothrow_swappable<_Tp>::value)
231      {
232	using std::swap;
233	swap(_M_t, get_underlying(__pt));
234      }
235
236    private:
237      _Tp _M_t;
238    };
239
240  // [propagate_const.relational], relational operators
241  template <typename _Tp>
242    constexpr bool
243    operator==(const propagate_const<_Tp>& __pt, nullptr_t)
244    {
245      return get_underlying(__pt) == nullptr;
246    }
247
248  template <typename _Tp>
249    constexpr bool
250    operator==(nullptr_t, const propagate_const<_Tp>& __pu)
251    {
252      return nullptr == get_underlying(__pu);
253    }
254
255  template <typename _Tp>
256    constexpr bool
257    operator!=(const propagate_const<_Tp>& __pt, nullptr_t)
258    {
259      return get_underlying(__pt) != nullptr;
260    }
261
262  template <typename _Tp>
263    constexpr bool operator!=(nullptr_t, const propagate_const<_Tp>& __pu)
264    {
265      return nullptr != get_underlying(__pu);
266    }
267
268  template <typename _Tp, typename _Up>
269    constexpr bool
270    operator==(const propagate_const<_Tp>& __pt,
271	       const propagate_const<_Up>& __pu)
272    {
273      return get_underlying(__pt) == get_underlying(__pu);
274    }
275
276  template <typename _Tp, typename _Up>
277    constexpr bool
278    operator!=(const propagate_const<_Tp>& __pt,
279	       const propagate_const<_Up>& __pu)
280    {
281      return get_underlying(__pt) != get_underlying(__pu);
282    }
283
284  template <typename _Tp, typename _Up>
285    constexpr bool
286    operator<(const propagate_const<_Tp>& __pt,
287	      const propagate_const<_Up>& __pu)
288    {
289      return get_underlying(__pt) < get_underlying(__pu);
290    }
291
292  template <typename _Tp, typename _Up>
293    constexpr bool
294    operator>(const propagate_const<_Tp>& __pt,
295	      const propagate_const<_Up>& __pu)
296    {
297      return get_underlying(__pt) > get_underlying(__pu);
298    }
299
300  template <typename _Tp, typename _Up>
301    constexpr bool
302    operator<=(const propagate_const<_Tp>& __pt,
303	       const propagate_const<_Up>& __pu)
304    {
305      return get_underlying(__pt) <= get_underlying(__pu);
306    }
307
308  template <typename _Tp, typename _Up>
309    constexpr bool
310    operator>=(const propagate_const<_Tp>& __pt,
311	       const propagate_const<_Up>& __pu)
312    {
313      return get_underlying(__pt) >= get_underlying(__pu);
314    }
315
316  template <typename _Tp, typename _Up>
317    constexpr bool
318    operator==(const propagate_const<_Tp>& __pt, const _Up& __u)
319    {
320      return get_underlying(__pt) == __u;
321    }
322
323  template <typename _Tp, typename _Up>
324    constexpr bool
325    operator!=(const propagate_const<_Tp>& __pt, const _Up& __u)
326    {
327      return get_underlying(__pt) != __u;
328    }
329
330  template <typename _Tp, typename _Up>
331    constexpr bool
332    operator<(const propagate_const<_Tp>& __pt, const _Up& __u)
333    {
334      return get_underlying(__pt) < __u;
335    }
336
337  template <typename _Tp, typename _Up>
338    constexpr bool
339    operator>(const propagate_const<_Tp>& __pt, const _Up& __u)
340    {
341      return get_underlying(__pt) > __u;
342    }
343
344  template <typename _Tp, typename _Up>
345    constexpr bool
346    operator<=(const propagate_const<_Tp>& __pt, const _Up& __u)
347    {
348      return get_underlying(__pt) <= __u;
349    }
350
351  template <typename _Tp, typename _Up>
352    constexpr bool
353    operator>=(const propagate_const<_Tp>& __pt, const _Up& __u)
354    {
355      return get_underlying(__pt) >= __u;
356    }
357
358  template <typename _Tp, typename _Up>
359    constexpr bool
360    operator==(const _Tp& __t, const propagate_const<_Up>& __pu)
361    {
362      return __t == get_underlying(__pu);
363    }
364
365  template <typename _Tp, typename _Up>
366    constexpr bool
367    operator!=(const _Tp& __t, const propagate_const<_Up>& __pu)
368    {
369      return __t != get_underlying(__pu);
370    }
371
372  template <typename _Tp, typename _Up>
373    constexpr bool
374    operator<(const _Tp& __t, const propagate_const<_Up>& __pu)
375    {
376      return __t < get_underlying(__pu);
377    }
378
379  template <typename _Tp, typename _Up>
380    constexpr bool
381    operator>(const _Tp& __t, const propagate_const<_Up>& __pu)
382    {
383      return __t > get_underlying(__pu);
384    }
385
386  template <typename _Tp, typename _Up>
387    constexpr bool
388    operator<=(const _Tp& __t, const propagate_const<_Up>& __pu)
389    {
390      return __t <= get_underlying(__pu);
391    }
392
393  template <typename _Tp, typename _Up>
394    constexpr bool
395    operator>=(const _Tp& __t, const propagate_const<_Up>& __pu)
396    {
397      return __t >= get_underlying(__pu);
398    }
399
400  // [propagate_const.algorithms], specialized algorithms
401  template <typename _Tp>
402    constexpr void
403    swap(propagate_const<_Tp>& __pt, propagate_const<_Tp>& __pt2)
404      noexcept(__is_nothrow_swappable<_Tp>::value)
405    {
406      __pt.swap(__pt2);
407    }
408
409  // [propagate_const.underlying], underlying pointer access
410  template <typename _Tp>
411    constexpr const _Tp&
412    get_underlying(const propagate_const<_Tp>& __pt) noexcept
413    {
414      return __pt._M_t;
415    }
416
417  template <typename _Tp>
418    constexpr _Tp&
419    get_underlying(propagate_const<_Tp>& __pt) noexcept
420    {
421      return __pt._M_t;
422    }
423
424  /// @} group propagate_const
425} // namespace fundamentals_v2
426} // namespace experimental
427
428// [propagate_const.hash], hash support
429 template <typename _Tp>
430   struct hash<experimental::propagate_const<_Tp>>
431   {
432     using result_type = size_t;
433     using argument_type = experimental::propagate_const<_Tp>;
434
435     size_t
436     operator()(const experimental::propagate_const<_Tp>& __t) const
437     noexcept(noexcept(hash<_Tp>{}(get_underlying(__t))))
438     {
439       return hash<_Tp>{}(get_underlying(__t));
440     }
441   };
442
443 // [propagate_const.comparison_function_objects], comparison function objects
444 template <typename _Tp>
445   struct equal_to<experimental::propagate_const<_Tp>>
446   {
447     constexpr bool
448     operator()(const experimental::propagate_const<_Tp>& __x,
449	        const experimental::propagate_const<_Tp>& __y) const
450     {
451       return equal_to<_Tp>{}(get_underlying(__x), get_underlying(__y));
452     }
453
454     typedef experimental::propagate_const<_Tp> first_argument_type;
455     typedef experimental::propagate_const<_Tp> second_argument_type;
456     typedef bool result_type;
457   };
458
459 template <typename _Tp>
460   struct not_equal_to<experimental::propagate_const<_Tp>>
461   {
462     constexpr bool
463     operator()(const experimental::propagate_const<_Tp>& __x,
464		const experimental::propagate_const<_Tp>& __y) const
465     {
466       return not_equal_to<_Tp>{}(get_underlying(__x), get_underlying(__y));
467     }
468
469     typedef experimental::propagate_const<_Tp> first_argument_type;
470     typedef experimental::propagate_const<_Tp> second_argument_type;
471     typedef bool result_type;
472   };
473
474 template <typename _Tp>
475   struct less<experimental::propagate_const<_Tp>>
476   {
477     constexpr bool
478     operator()(const experimental::propagate_const<_Tp>& __x,
479		const experimental::propagate_const<_Tp>& __y) const
480     {
481       return less<_Tp>{}(get_underlying(__x), get_underlying(__y));
482     }
483
484     typedef experimental::propagate_const<_Tp> first_argument_type;
485     typedef experimental::propagate_const<_Tp> second_argument_type;
486     typedef bool result_type;
487   };
488
489 template <typename _Tp>
490   struct greater<experimental::propagate_const<_Tp>>
491   {
492     constexpr bool
493     operator()(const experimental::propagate_const<_Tp>& __x,
494		const experimental::propagate_const<_Tp>& __y) const
495     {
496       return greater<_Tp>{}(get_underlying(__x), get_underlying(__y));
497     }
498
499     typedef experimental::propagate_const<_Tp> first_argument_type;
500     typedef experimental::propagate_const<_Tp> second_argument_type;
501     typedef bool result_type;
502   };
503
504 template <typename _Tp>
505   struct less_equal<experimental::propagate_const<_Tp>>
506   {
507     constexpr bool
508     operator()(const experimental::propagate_const<_Tp>& __x,
509	        const experimental::propagate_const<_Tp>& __y) const
510     {
511       return less_equal<_Tp>{}(get_underlying(__x), get_underlying(__y));
512     }
513
514     typedef experimental::propagate_const<_Tp> first_argument_type;
515     typedef experimental::propagate_const<_Tp> second_argument_type;
516     typedef bool result_type;
517   };
518
519 template <typename _Tp>
520   struct greater_equal<experimental::propagate_const<_Tp>>
521   {
522     constexpr bool
523     operator()(const experimental::propagate_const<_Tp>& __x,
524		const experimental::propagate_const<_Tp>& __y) const
525     {
526       return greater_equal<_Tp>{}(get_underlying(__x), get_underlying(__y));
527     }
528
529     typedef experimental::propagate_const<_Tp> first_argument_type;
530     typedef experimental::propagate_const<_Tp> second_argument_type;
531     typedef bool result_type;
532   };
533
534_GLIBCXX_END_NAMESPACE_VERSION
535} // namespace std
536
537#endif // C++14
538
539#endif // _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST
540