<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/include/c++/11/experimental/propagate_const</h2><form method='post'><textarea name='content' class='file-edit'>// &lt;experimental/propagate_const&gt; -*- C++ -*-

// Copyright (C) 2015-2021 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/** @file experimental/propagate_const
 *  This is a TS C++ Library header.
 *  @ingroup libfund-ts
 */

#ifndef _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST
#define _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST 1

#pragma GCC system_header

#if __cplusplus &gt;= 201402L

#include &lt;type_traits&gt;
#include &lt;bits/functional_hash.h&gt;
#include &lt;bits/move.h&gt;
#include &lt;bits/stl_function.h&gt;
#include &lt;experimental/bits/lfts_config.h&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace experimental
{
inline namespace fundamentals_v2
{
  /**
   * @defgroup propagate_const Const-propagating wrapper
   * @ingroup libfund-ts
   *
   * A const-propagating wrapper that propagates const to pointer-like members,
   * as described in n4388 &quot;A Proposal to Add a Const-Propagating Wrapper
   * to the Standard Library&quot;.
   *
   * @{
   */

  /// Const-propagating wrapper.
  template &lt;typename _Tp&gt;
    class propagate_const
    {
    public:
      typedef remove_reference_t&lt;decltype(*std::declval&lt;_Tp&amp;&gt;())&gt; element_type;

    private:
      template &lt;typename _Up&gt;
	struct __is_propagate_const : false_type
	{ };

      template &lt;typename _Up&gt;
	struct __is_propagate_const&lt;propagate_const&lt;_Up&gt;&gt; : true_type
	{ };

      template &lt;typename _Up&gt;
	friend constexpr const _Up&amp;
	get_underlying(const propagate_const&lt;_Up&gt;&amp; __pt) noexcept;
      template &lt;typename _Up&gt;
	friend constexpr _Up&amp;
	get_underlying(propagate_const&lt;_Up&gt;&amp; __pt) noexcept;

      template &lt;typename _Up&gt;
	static constexpr element_type*
	__to_raw_pointer(_Up* __u)
	{ return __u; }

      template &lt;typename _Up&gt;
	static constexpr element_type*
	__to_raw_pointer(_Up&amp; __u)
	{ return __u.get(); }

      template &lt;typename _Up&gt;
	static constexpr const element_type*
	__to_raw_pointer(const _Up* __u)
	{ return __u; }

      template &lt;typename _Up&gt;
	static constexpr const element_type*
	__to_raw_pointer(const _Up&amp; __u)
	{ return __u.get(); }

    public:
      static_assert(__and_&lt;is_object&lt;typename remove_pointer&lt;_Tp&gt;::type&gt;,
			   __not_&lt;is_array&lt;_Tp&gt;&gt;,
			   __or_&lt;is_class&lt;_Tp&gt;, is_pointer&lt;_Tp&gt;&gt;&gt;::value,
		    &quot;propagate_const requires a class or a pointer to an&quot;
		    &quot; object type&quot;);

      // [propagate_const.ctor], constructors
      constexpr propagate_const() = default;
      propagate_const(const propagate_const&amp; __p) = delete;
      constexpr propagate_const(propagate_const&amp;&amp; __p) = default;

      template &lt;typename _Up, typename
		enable_if&lt;__and_&lt;is_constructible&lt;_Tp, _Up&amp;&amp;&gt;,
				 is_convertible&lt;_Up&amp;&amp;, _Tp&gt;&gt;::value, bool
			  &gt;::type=true&gt;
      constexpr propagate_const(propagate_const&lt;_Up&gt;&amp;&amp; __pu)
	: _M_t(std::move(get_underlying(__pu)))
      {}

      template &lt;typename _Up, typename
		enable_if&lt;__and_&lt;is_constructible&lt;_Tp, _Up&amp;&amp;&gt;,
				 __not_&lt;is_convertible&lt;_Up&amp;&amp;, _Tp&gt;&gt;&gt;::value,
			  bool&gt;::type=false&gt;
      constexpr explicit propagate_const(propagate_const&lt;_Up&gt;&amp;&amp; __pu)
	: _M_t(std::move(get_underlying(__pu)))
      {}

      template &lt;typename _Up, typename
		enable_if&lt;__and_&lt;is_constructible&lt;_Tp, _Up&amp;&amp;&gt;,
				 is_convertible&lt;_Up&amp;&amp;, _Tp&gt;,
				 __not_&lt;__is_propagate_const&lt;
					  typename decay&lt;_Up&gt;::type&gt;&gt;
				 &gt;::value, bool&gt;::type=true&gt;
      constexpr propagate_const(_Up&amp;&amp; __u)
	: _M_t(std::forward&lt;_Up&gt;(__u))
      {}

      template &lt;typename _Up, typename
		enable_if&lt;__and_&lt;is_constructible&lt;_Tp, _Up&amp;&amp;&gt;,
				 __not_&lt;is_convertible&lt;_Up&amp;&amp;, _Tp&gt;&gt;,
				 __not_&lt;__is_propagate_const&lt;
					  typename decay&lt;_Up&gt;::type&gt;&gt;
				 &gt;::value, bool&gt;::type=false&gt;
      constexpr explicit propagate_const(_Up&amp;&amp; __u)
	: _M_t(std::forward&lt;_Up&gt;(__u))
      {}

      // [propagate_const.assignment], assignment
      propagate_const&amp; operator=(const propagate_const&amp; __p) = delete;
      constexpr propagate_const&amp; operator=(propagate_const&amp;&amp; __p) = default;

      template &lt;typename _Up, typename =
		typename enable_if&lt;is_convertible&lt;_Up&amp;&amp;, _Tp&gt;::value&gt;::type&gt;
      constexpr propagate_const&amp; operator=(propagate_const&lt;_Up&gt;&amp;&amp; __pu)
      {
	_M_t = std::move(get_underlying(__pu));
	return *this;
      }

      template &lt;typename _Up, typename =
		typename enable_if&lt;__and_&lt;is_convertible&lt;_Up&amp;&amp;, _Tp&gt;,
					  __not_&lt;__is_propagate_const&lt;
						   typename decay&lt;_Up&gt;::type&gt;&gt;
					  &gt;::value&gt;::type&gt;
      constexpr propagate_const&amp; operator=(_Up&amp;&amp; __u)
      {
	_M_t = std::forward&lt;_Up&gt;(__u);
	return *this;
      }

      // [propagate_const.const_observers], const observers
      explicit constexpr operator bool() const
      {
	return bool(_M_t);
      }

      constexpr const element_type* operator-&gt;() const
      {
	return get();
      }

      template &lt;typename _Up = _Tp,
		typename enable_if&lt;__or_&lt;is_pointer&lt;_Up&gt;,
					 is_convertible&lt;_Up,
							const element_type*&gt;
					 &gt;::value, bool&gt;::type = true&gt;
      constexpr operator const element_type*() const
      {
	return get();
      }

      constexpr const element_type&amp; operator*() const
      {
	return *get();
      }

      constexpr const element_type* get() const
      {
	return __to_raw_pointer(_M_t);
      }

      // [propagate_const.non_const_observers], non-const observers
      constexpr element_type* operator-&gt;()
      {
	return get();
      }

      template &lt;typename _Up = _Tp,
		typename enable_if&lt;__or_&lt;is_pointer&lt;_Up&gt;,
					 is_convertible&lt;_Up,
						        const element_type*&gt;
					 &gt;::value, bool&gt;::type = true&gt;
      constexpr operator element_type*()
      {
	return get();
      }

      constexpr element_type&amp; operator*()
      {
	return *get();
      }

      constexpr element_type* get()
      {
	return __to_raw_pointer(_M_t);
      }

      // [propagate_const.modifiers], modifiers
      constexpr void
      swap(propagate_const&amp; __pt) noexcept(__is_nothrow_swappable&lt;_Tp&gt;::value)
      {
	using std::swap;
	swap(_M_t, get_underlying(__pt));
      }

    private:
      _Tp _M_t;
    };

  // [propagate_const.relational], relational operators
  template &lt;typename _Tp&gt;
    constexpr bool
    operator==(const propagate_const&lt;_Tp&gt;&amp; __pt, nullptr_t)
    {
      return get_underlying(__pt) == nullptr;
    }

  template &lt;typename _Tp&gt;
    constexpr bool
    operator==(nullptr_t, const propagate_const&lt;_Tp&gt;&amp; __pu)
    {
      return nullptr == get_underlying(__pu);
    }

  template &lt;typename _Tp&gt;
    constexpr bool
    operator!=(const propagate_const&lt;_Tp&gt;&amp; __pt, nullptr_t)
    {
      return get_underlying(__pt) != nullptr;
    }

  template &lt;typename _Tp&gt;
    constexpr bool operator!=(nullptr_t, const propagate_const&lt;_Tp&gt;&amp; __pu)
    {
      return nullptr != get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator==(const propagate_const&lt;_Tp&gt;&amp; __pt,
	       const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return get_underlying(__pt) == get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator!=(const propagate_const&lt;_Tp&gt;&amp; __pt,
	       const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return get_underlying(__pt) != get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&lt;(const propagate_const&lt;_Tp&gt;&amp; __pt,
	      const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return get_underlying(__pt) &lt; get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&gt;(const propagate_const&lt;_Tp&gt;&amp; __pt,
	      const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return get_underlying(__pt) &gt; get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&lt;=(const propagate_const&lt;_Tp&gt;&amp; __pt,
	       const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return get_underlying(__pt) &lt;= get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&gt;=(const propagate_const&lt;_Tp&gt;&amp; __pt,
	       const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return get_underlying(__pt) &gt;= get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator==(const propagate_const&lt;_Tp&gt;&amp; __pt, const _Up&amp; __u)
    {
      return get_underlying(__pt) == __u;
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator!=(const propagate_const&lt;_Tp&gt;&amp; __pt, const _Up&amp; __u)
    {
      return get_underlying(__pt) != __u;
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&lt;(const propagate_const&lt;_Tp&gt;&amp; __pt, const _Up&amp; __u)
    {
      return get_underlying(__pt) &lt; __u;
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&gt;(const propagate_const&lt;_Tp&gt;&amp; __pt, const _Up&amp; __u)
    {
      return get_underlying(__pt) &gt; __u;
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&lt;=(const propagate_const&lt;_Tp&gt;&amp; __pt, const _Up&amp; __u)
    {
      return get_underlying(__pt) &lt;= __u;
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&gt;=(const propagate_const&lt;_Tp&gt;&amp; __pt, const _Up&amp; __u)
    {
      return get_underlying(__pt) &gt;= __u;
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator==(const _Tp&amp; __t, const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return __t == get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator!=(const _Tp&amp; __t, const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return __t != get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&lt;(const _Tp&amp; __t, const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return __t &lt; get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&gt;(const _Tp&amp; __t, const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return __t &gt; get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&lt;=(const _Tp&amp; __t, const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return __t &lt;= get_underlying(__pu);
    }

  template &lt;typename _Tp, typename _Up&gt;
    constexpr bool
    operator&gt;=(const _Tp&amp; __t, const propagate_const&lt;_Up&gt;&amp; __pu)
    {
      return __t &gt;= get_underlying(__pu);
    }

  // [propagate_const.algorithms], specialized algorithms
  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // 3413. propagate_const's swap [...] needs to be constrained and use a trait
  template &lt;typename _Tp&gt;
    constexpr enable_if_t&lt;__is_swappable&lt;_Tp&gt;::value, void&gt;
    swap(propagate_const&lt;_Tp&gt;&amp; __pt, propagate_const&lt;_Tp&gt;&amp; __pt2)
      noexcept(__is_nothrow_swappable&lt;_Tp&gt;::value)
    {
      __pt.swap(__pt2);
    }

  // [propagate_const.underlying], underlying pointer access
  template &lt;typename _Tp&gt;
    constexpr const _Tp&amp;
    get_underlying(const propagate_const&lt;_Tp&gt;&amp; __pt) noexcept
    {
      return __pt._M_t;
    }

  template &lt;typename _Tp&gt;
    constexpr _Tp&amp;
    get_underlying(propagate_const&lt;_Tp&gt;&amp; __pt) noexcept
    {
      return __pt._M_t;
    }

  /// @} group propagate_const
} // namespace fundamentals_v2
} // namespace experimental

// [propagate_const.hash], hash support
 template &lt;typename _Tp&gt;
   struct hash&lt;experimental::propagate_const&lt;_Tp&gt;&gt;
   {
     using result_type = size_t;
     using argument_type = experimental::propagate_const&lt;_Tp&gt;;

     size_t
     operator()(const experimental::propagate_const&lt;_Tp&gt;&amp; __t) const
     noexcept(noexcept(hash&lt;_Tp&gt;{}(get_underlying(__t))))
     {
       return hash&lt;_Tp&gt;{}(get_underlying(__t));
     }
   };

 // [propagate_const.comparison_function_objects], comparison function objects
 template &lt;typename _Tp&gt;
   struct equal_to&lt;experimental::propagate_const&lt;_Tp&gt;&gt;
   {
     constexpr bool
     operator()(const experimental::propagate_const&lt;_Tp&gt;&amp; __x,
	        const experimental::propagate_const&lt;_Tp&gt;&amp; __y) const
     {
       return equal_to&lt;_Tp&gt;{}(get_underlying(__x), get_underlying(__y));
     }

     typedef experimental::propagate_const&lt;_Tp&gt; first_argument_type;
     typedef experimental::propagate_const&lt;_Tp&gt; second_argument_type;
     typedef bool result_type;
   };

 template &lt;typename _Tp&gt;
   struct not_equal_to&lt;experimental::propagate_const&lt;_Tp&gt;&gt;
   {
     constexpr bool
     operator()(const experimental::propagate_const&lt;_Tp&gt;&amp; __x,
		const experimental::propagate_const&lt;_Tp&gt;&amp; __y) const
     {
       return not_equal_to&lt;_Tp&gt;{}(get_underlying(__x), get_underlying(__y));
     }

     typedef experimental::propagate_const&lt;_Tp&gt; first_argument_type;
     typedef experimental::propagate_const&lt;_Tp&gt; second_argument_type;
     typedef bool result_type;
   };

 template &lt;typename _Tp&gt;
   struct less&lt;experimental::propagate_const&lt;_Tp&gt;&gt;
   {
     constexpr bool
     operator()(const experimental::propagate_const&lt;_Tp&gt;&amp; __x,
		const experimental::propagate_const&lt;_Tp&gt;&amp; __y) const
     {
       return less&lt;_Tp&gt;{}(get_underlying(__x), get_underlying(__y));
     }

     typedef experimental::propagate_const&lt;_Tp&gt; first_argument_type;
     typedef experimental::propagate_const&lt;_Tp&gt; second_argument_type;
     typedef bool result_type;
   };

 template &lt;typename _Tp&gt;
   struct greater&lt;experimental::propagate_const&lt;_Tp&gt;&gt;
   {
     constexpr bool
     operator()(const experimental::propagate_const&lt;_Tp&gt;&amp; __x,
		const experimental::propagate_const&lt;_Tp&gt;&amp; __y) const
     {
       return greater&lt;_Tp&gt;{}(get_underlying(__x), get_underlying(__y));
     }

     typedef experimental::propagate_const&lt;_Tp&gt; first_argument_type;
     typedef experimental::propagate_const&lt;_Tp&gt; second_argument_type;
     typedef bool result_type;
   };

 template &lt;typename _Tp&gt;
   struct less_equal&lt;experimental::propagate_const&lt;_Tp&gt;&gt;
   {
     constexpr bool
     operator()(const experimental::propagate_const&lt;_Tp&gt;&amp; __x,
	        const experimental::propagate_const&lt;_Tp&gt;&amp; __y) const
     {
       return less_equal&lt;_Tp&gt;{}(get_underlying(__x), get_underlying(__y));
     }

     typedef experimental::propagate_const&lt;_Tp&gt; first_argument_type;
     typedef experimental::propagate_const&lt;_Tp&gt; second_argument_type;
     typedef bool result_type;
   };

 template &lt;typename _Tp&gt;
   struct greater_equal&lt;experimental::propagate_const&lt;_Tp&gt;&gt;
   {
     constexpr bool
     operator()(const experimental::propagate_const&lt;_Tp&gt;&amp; __x,
		const experimental::propagate_const&lt;_Tp&gt;&amp; __y) const
     {
       return greater_equal&lt;_Tp&gt;{}(get_underlying(__x), get_underlying(__y));
     }

     typedef experimental::propagate_const&lt;_Tp&gt; first_argument_type;
     typedef experimental::propagate_const&lt;_Tp&gt; second_argument_type;
     typedef bool result_type;
   };

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // C++14

#endif // _GLIBCXX_EXPERIMENTAL_PROPAGATE_CONST
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Finclude%2Fc%2B%2B%2F11%2Fexperimental'>Back to Directory</a>