<h2>Editing File: /usr/include/c++/8/experimental/memory</h2><form method='post'><textarea name='content' class='file-edit'>// &lt;experimental/memory&gt; -*- C++ -*-

// Copyright (C) 2015-2018 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/memory
 *  This is a TS C++ Library header.
 */

//
// N4336 Working Draft, C++ Extensions for Library Fundamentals, Version 2
//

#ifndef _GLIBCXX_EXPERIMENTAL_MEMORY
#define _GLIBCXX_EXPERIMENTAL_MEMORY 1

#pragma GCC system_header

#if __cplusplus &gt;= 201402L

#include &lt;memory&gt;
#include &lt;type_traits&gt;
#include &lt;utility&gt;
#include &lt;experimental/bits/shared_ptr.h&gt;
#include &lt;bits/functional_hash.h&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

namespace experimental
{
inline namespace fundamentals_v2
{
#define __cpp_lib_experimental_observer_ptr 201411

  template &lt;typename _Tp&gt;
    class observer_ptr
    {
    public:
      // publish our template parameter and variations thereof
      using element_type = _Tp;
      using __pointer = add_pointer_t&lt;_Tp&gt;;            // exposition-only
      using __reference = add_lvalue_reference_t&lt;_Tp&gt;; // exposition-only

      // 3.2.2, observer_ptr constructors
      // default c’tor
      constexpr observer_ptr() noexcept
      : __t()
      { }

      // pointer-accepting c’tors
      constexpr observer_ptr(nullptr_t) noexcept
      : __t()
      { }

      constexpr explicit observer_ptr(__pointer __p) noexcept
      : __t(__p)
      { }

      // copying c’tors (in addition to compiler-generated copy c’tor)
      template &lt;typename _Up,
		typename = typename enable_if&lt;
		  is_convertible&lt;typename add_pointer&lt;_Up&gt;::type, __pointer
		  &gt;::value
		&gt;::type&gt;
      constexpr observer_ptr(observer_ptr&lt;_Up&gt; __p) noexcept
      : __t(__p.get())
      {
      }

      // 3.2.3, observer_ptr observers
      constexpr __pointer
      get() const noexcept
      {
	return __t;
      }

      constexpr __reference
      operator*() const
      {
	return *get();
      }

      constexpr __pointer
      operator-&gt;() const noexcept
      {
	return get();
      }

      constexpr explicit operator bool() const noexcept
      {
	return get() != nullptr;
      }

      // 3.2.4, observer_ptr conversions
      constexpr explicit operator __pointer() const noexcept
      {
	return get();
      }

      // 3.2.5, observer_ptr modifiers
      constexpr __pointer
      release() noexcept
      {
	__pointer __tmp = get();
	reset();
	return __tmp;
      }

      constexpr void
      reset(__pointer __p = nullptr) noexcept
      {
	__t = __p;
      }

      constexpr void
      swap(observer_ptr&amp; __p) noexcept
      {
	std::swap(__t, __p.__t);
      }

    private:
      __pointer __t;
    }; // observer_ptr&lt;&gt;

  template&lt;typename _Tp&gt;
    void
    swap(observer_ptr&lt;_Tp&gt;&amp; __p1, observer_ptr&lt;_Tp&gt;&amp; __p2) noexcept
    {
      __p1.swap(__p2);
    }

  template&lt;typename _Tp&gt;
    observer_ptr&lt;_Tp&gt;
    make_observer(_Tp* __p) noexcept
    {
      return observer_ptr&lt;_Tp&gt;(__p);
    }

  template&lt;typename _Tp, typename _Up&gt;
    bool
    operator==(observer_ptr&lt;_Tp&gt; __p1, observer_ptr&lt;_Up&gt; __p2)
    {
      return __p1.get() == __p2.get();
    }

  template&lt;typename _Tp, typename _Up&gt;
    bool
    operator!=(observer_ptr&lt;_Tp&gt; __p1, observer_ptr&lt;_Up&gt; __p2)
    {
    return !(__p1 == __p2);
    }

  template&lt;typename _Tp&gt;
    bool
    operator==(observer_ptr&lt;_Tp&gt; __p, nullptr_t) noexcept
    {
      return !__p;
    }

  template&lt;typename _Tp&gt;
    bool
    operator==(nullptr_t, observer_ptr&lt;_Tp&gt; __p) noexcept
    {
      return !__p;
    }

  template&lt;typename _Tp&gt;
    bool
    operator!=(observer_ptr&lt;_Tp&gt; __p, nullptr_t) noexcept
    {
      return bool(__p);
    }

  template&lt;typename _Tp&gt;
    bool
    operator!=(nullptr_t, observer_ptr&lt;_Tp&gt; __p) noexcept
    {
      return bool(__p);
    }

  template&lt;typename _Tp, typename _Up&gt;
    bool
    operator&lt;(observer_ptr&lt;_Tp&gt; __p1, observer_ptr&lt;_Up&gt; __p2)
    {
      return std::less&lt;typename common_type&lt;typename add_pointer&lt;_Tp&gt;::type,
					    typename add_pointer&lt;_Up&gt;::type
					    &gt;::type
		       &gt;{}(__p1.get(), __p2.get());
    }

  template&lt;typename _Tp, typename _Up&gt;
    bool
    operator&gt;(observer_ptr&lt;_Tp&gt; __p1, observer_ptr&lt;_Up&gt; __p2)
    {
      return __p2 &lt; __p1;
    }

  template&lt;typename _Tp, typename _Up&gt;
    bool
    operator&lt;=(observer_ptr&lt;_Tp&gt; __p1, observer_ptr&lt;_Up&gt; __p2)
    {
      return !(__p2 &lt; __p1);
    }

  template&lt;typename _Tp, typename _Up&gt;
    bool
    operator&gt;=(observer_ptr&lt;_Tp&gt; __p1, observer_ptr&lt;_Up&gt; __p2)
    {
      return !(__p1 &lt; __p2);
    }
} // namespace fundamentals_v2
} // namespace experimental

template &lt;typename _Tp&gt;
  struct hash&lt;experimental::observer_ptr&lt;_Tp&gt;&gt;
  {
    using result_type = size_t;
    using argument_type = experimental::observer_ptr&lt;_Tp&gt;;

    size_t
    operator()(const experimental::observer_ptr&lt;_Tp&gt;&amp; __t) const
    noexcept(noexcept(hash&lt;typename add_pointer&lt;_Tp&gt;::type&gt; {}(__t.get())))
    {
      return hash&lt;typename add_pointer&lt;_Tp&gt;::type&gt; {}(__t.get());
    }
  };


_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif // __cplusplus &lt;= 201103L

#endif // _GLIBCXX_EXPERIMENTAL_MEMORY
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fexperimental'>Back to Directory</a>