[libstdc++ PATCH] Implement observer_ptr

[libstdc++ PATCH] Implement observer_ptr

[Ville Voutilainen]

[-- Attachment #1: Type: text/plain, Size: 844 bytes --]

Tested on Linux-x64.

2015-05-01  Ville Voutilainen  <ville.voutilainen@gmail.com>
    Implement observer_ptr.
    * include/Makefile.am: Add new exported header.
    * include/Makefile.in: Regenerate.
    * include/experimental/memory: New.
    * testsuite/experimental/memory/observer_ptr/assignment/assign.cc: Likewise.
    * testsuite/experimental/memory/observer_ptr/cons/cons.cc: Likewise.
    * testsuite/experimental/memory/observer_ptr/hash/hash.cc: Likewise.
    * testsuite/experimental/memory/observer_ptr/make_observer.cc: Likewise.
    * testsuite/experimental/memory/observer_ptr/relops/relops.cc: Likewise.
    * testsuite/experimental/memory/observer_ptr/requirements.cc: Likewise.
    * testsuite/experimental/memory/observer_ptr/swap/swap.cc: Likewise.
    * testsuite/experimental/memory/observer_ptr/typedefs.cc: Likewise.

[-- Attachment #2: observer_ptr.diff --]
[-- Type: text/plain, Size: 23300 bytes --]

diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 2677132..5962e23 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -647,6 +647,7 @@ experimental_headers = \
 	${experimental_srcdir}/any \
 	${experimental_srcdir}/chrono \
 	${experimental_srcdir}/functional \
+	${experimental_srcdir}/memory \
 	${experimental_srcdir}/optional \
 	${experimental_srcdir}/ratio \
 	${experimental_srcdir}/string_view \
diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in
index 9c423cb..1a13b89 100644
--- a/libstdc++-v3/include/Makefile.in
+++ b/libstdc++-v3/include/Makefile.in
@@ -914,6 +914,7 @@ experimental_headers = \
 	${experimental_srcdir}/any \
 	${experimental_srcdir}/chrono \
 	${experimental_srcdir}/functional \
+	${experimental_srcdir}/memory \
 	${experimental_srcdir}/optional \
 	${experimental_srcdir}/ratio \
 	${experimental_srcdir}/string_view \
diff --git a/libstdc++-v3/include/experimental/memory b/libstdc++-v3/include/experimental/memory
new file mode 100644
index 0000000..6b2e78e
--- /dev/null
+++ b/libstdc++-v3/include/experimental/memory
@@ -0,0 +1,233 @@
+// <experimental/memory> -*- C++ -*-
+
+// Copyright (C) 2015 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
+// <http://www.gnu.org/licenses/>.
+
+/** @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 <= 201103L
+# include <bits/c++14_warning.h>
+#else
+
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <functional>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+namespace experimental
+{
+inline namespace fundamentals_v2
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+template <typename _Tp> class observer_ptr {
+public:
+  // publish our template parameter and variations thereof
+  using element_type = _Tp;
+  using __pointer = add_pointer_t<_Tp>;            // exposition-only
+  using __reference = add_lvalue_reference_t<_Tp>; // 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 <typename _Up,
+            typename = typename enable_if<
+              is_convertible<typename add_pointer<_Up>::type, __pointer
+              >::value
+            >::type> 
+  constexpr observer_ptr(observer_ptr<_Up> __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->() 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& __p) noexcept
+  {
+    std::swap(__t, __p.__t);
+  }
+
+private:
+  __pointer __t;
+}; // observer_ptr<>
+
+  template <class _Tp>
+  void swap(observer_ptr<_Tp>& __p1, observer_ptr<_Tp>& __p2) noexcept
+  {
+    __p1.swap(__p2);
+  }
+    
+  template <class _Tp> observer_ptr<_Tp> make_observer(_Tp* __p) noexcept
+  {
+    return observer_ptr<_Tp>(__p);
+  }
+  
+  template <class _Tp, class _Up>
+  bool operator==(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
+  {
+    return __p1.get() == __p2.get();
+  }
+  
+  template <class _Tp, class _Up>
+  bool operator!=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
+  {
+  return !(__p1 == __p2);
+  }
+
+  template <class _Tp>
+  bool operator==(observer_ptr<_Tp> __p, nullptr_t) noexcept
+  {
+    return !__p;
+  }
+
+  template <class _Tp>
+  bool operator==(nullptr_t, observer_ptr<_Tp> __p) noexcept
+  {
+    return !__p;
+  }
+
+  template <class _Tp>
+  bool operator!=(observer_ptr<_Tp> __p, nullptr_t) noexcept
+  {
+    return bool(__p);
+  }
+
+  template <class _Tp>
+  bool operator!=(nullptr_t, observer_ptr<_Tp> __p) noexcept
+  {
+    return bool(__p);
+  }
+
+  template <class _Tp, class _Up>
+  bool operator<(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
+  {
+    return std::less<typename common_type<typename add_pointer<_Tp>::type,
+                                          typename add_pointer<_Up>::type
+                                          >::type
+                     >{}(__p1.get(), __p2.get());
+  }
+
+  template <class _Tp, class _Up>
+  bool operator>(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
+  {
+    return __p2 < __p1;
+  }
+
+  template <class _Tp, class _Up>
+  bool operator<=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
+  {
+    return !(__p2 < __p1);
+  }
+
+  template <class _Tp, class _Up>
+  bool operator>=(observer_ptr<_Tp> __p1, observer_ptr<_Up> __p2)
+  {
+    return !(__p1 < __p2);
+  }
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace fundamentals_v2
+} // namespace experimental
+
+template <typename _Tp> 
+  struct hash<experimental::observer_ptr<_Tp>>
+  {
+    using result_type = size_t;
+    using argument_type = experimental::observer_ptr<_Tp>;
+    size_t
+      operator()(const experimental::observer_ptr<_Tp>& __t) const
+      noexcept(noexcept(hash<typename add_pointer<_Tp>::type> {}(__t.get())))
+    {
+      return hash<typename add_pointer<_Tp>::type> {}(__t.get());
+    }
+    
+  };
+
+} // namespace std
+
+#endif // __cplusplus <= 201103L
+
+#endif // _GLIBCXX_EXPERIMENTAL_MEMORY
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/assignment/assign.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/assignment/assign.cc
new file mode 100644
index 0000000..6ccf407
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/assignment/assign.cc
@@ -0,0 +1,89 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do run }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+#include <testsuite_hooks.h>
+
+using std::experimental::observer_ptr;
+
+struct B {};
+struct D : B {};
+
+void test01()
+{
+  observer_ptr<int> a, b;
+  a = b;
+  VERIFY(a == b);
+}
+
+void test02()
+{
+  int x{};
+  observer_ptr<int> a;
+  observer_ptr<int> b{&x};
+  VERIFY(a != b);
+  a = b;
+  VERIFY(a == b);
+}
+
+void test03()
+{
+  int x{};
+  observer_ptr<const int> a;
+  observer_ptr<int> b{&x};
+  VERIFY(a != b);
+  a = b;
+  VERIFY(a == b);
+}
+
+void test04()
+{
+  D x{};
+  observer_ptr<B> a;
+  observer_ptr<D> b{&x};
+  VERIFY(a != b);
+  a = b;
+  VERIFY(a == b);
+}
+
+constexpr bool test05_helper(observer_ptr<const int> a, 
+                             observer_ptr<const int> b)
+{
+  a = b;
+  return (a.get() == b.get());
+}
+
+void test05()
+{
+  static constexpr int x{};
+  constexpr observer_ptr<const int> a;
+  constexpr observer_ptr<const int> b{&x};
+  constexpr bool assigned = test05_helper(a, b);
+  VERIFY(assigned);
+}
+
+int main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+  test05();
+}
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/cons/cons.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/cons/cons.cc
new file mode 100644
index 0000000..c6c435b
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/cons/cons.cc
@@ -0,0 +1,92 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do run }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+#include <testsuite_hooks.h>
+#include <utility>
+
+using std::experimental::observer_ptr;
+
+struct B {};
+struct D : B {};
+
+void test01()
+{
+  observer_ptr<int> a;
+  VERIFY(!a);
+  observer_ptr<int> b{nullptr};
+  VERIFY(!b);
+}
+
+void test02()
+{
+  int x{};
+  observer_ptr<int> a{&x};
+  observer_ptr<int> b{a};
+  VERIFY(a == b);
+}
+
+void test03()
+{
+  int x{};
+  observer_ptr<int> a;
+  observer_ptr<const int> b{a};
+  VERIFY(a == b);
+}
+
+void test04()
+{
+  D x{};
+  observer_ptr<D> a{&x};
+  observer_ptr<B> b{a};
+  VERIFY(a == b);
+}
+
+void test05()
+{
+  D x{};
+  observer_ptr<D> a{&x};
+  observer_ptr<B> b{std::move(a)};
+  VERIFY(a == b);
+}
+
+void test06()
+{
+  static constexpr D x{};
+  constexpr observer_ptr<const D> a{&x};
+  constexpr observer_ptr<const B> b{std::move(a)};
+  VERIFY(a == b);
+  constexpr observer_ptr<const B> c{a};
+  VERIFY(a == b && a == c && b == c);
+  constexpr observer_ptr<int> d;
+  constexpr observer_ptr<int> e{nullptr};
+  VERIFY(!d);
+  VERIFY(!e);
+}
+
+int main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+  test05();
+  test06();
+}
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/hash/hash.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/hash/hash.cc
new file mode 100644
index 0000000..eb318fc
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/hash/hash.cc
@@ -0,0 +1,46 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do run }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+#include <testsuite_hooks.h>
+
+using std::experimental::observer_ptr;
+
+struct B {};
+struct D : B {};
+
+void test01()
+{
+  observer_ptr<int> a;
+  VERIFY(std::hash<observer_ptr<int>>{}(a) == std::hash<int*>{}(nullptr));
+}
+
+void test02()
+{
+  int x{};
+  observer_ptr<int> a{&x};
+  VERIFY(std::hash<observer_ptr<int>>{}(a) == std::hash<int*>{}(&x));
+}
+
+int main()
+{
+  test01();
+  test02();
+}
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/make_observer.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/make_observer.cc
new file mode 100644
index 0000000..b6075fa
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/make_observer.cc
@@ -0,0 +1,32 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do run }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+#include <testsuite_hooks.h>
+
+int main()
+{
+  const int i = 42;
+  auto o = std::experimental::make_observer(&i);
+  static_assert( std::is_same<decltype(o),
+                 std::experimental::observer_ptr<const int>>(), "" );
+  VERIFY( o && *o == 42 );
+  VERIFY( o.get() == &i );
+}
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/relops/relops.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/relops/relops.cc
new file mode 100644
index 0000000..9cf39de
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/relops/relops.cc
@@ -0,0 +1,80 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do run }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+#include <testsuite_hooks.h>
+
+using std::experimental::observer_ptr;
+
+void test01()
+{
+  observer_ptr<int> a, b;
+  VERIFY(a == b);
+}
+
+void test02()
+{
+  int x[2]{};
+  observer_ptr<int> a{&x[0]};
+  observer_ptr<int> b{&x[1]};
+  VERIFY(a != b);
+  VERIFY(a < b);
+  VERIFY(a <= b);
+  VERIFY(b >= a);
+  VERIFY(b > a);
+}
+
+void test03()
+{
+  int x{};
+  observer_ptr<int> a{&x};
+  observer_ptr<int> b{&x};
+  VERIFY(a == b);
+}
+
+void test04()
+{
+  static constexpr int x[2]{};
+  constexpr observer_ptr<const int> a{&x[0]};
+  constexpr observer_ptr<const int> b{&x[1]};
+  VERIFY(a != b);
+  VERIFY(a < b);
+  VERIFY(a <= b);
+  VERIFY(b >= a);
+  VERIFY(b > a);
+}
+
+void test05()
+{
+  static constexpr int x{};
+  constexpr observer_ptr<const int> a{&x};
+  constexpr observer_ptr<const int> b{&x};
+  VERIFY(a == b);
+}
+
+
+int main()
+{
+  test01();
+  test02();
+  test03();
+  test04();
+  test05();
+}
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/requirements.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/requirements.cc
new file mode 100644
index 0000000..36ffcab
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/requirements.cc
@@ -0,0 +1,65 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do compile }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+
+using std::experimental::observer_ptr;
+
+struct nontrivial {nontrivial() {}};
+struct other {};
+struct base {};
+struct derived : base {};
+
+static_assert(!std::is_trivially_constructible<
+              observer_ptr<nontrivial>>::value, "");
+static_assert(std::is_trivially_copyable<
+              observer_ptr<nontrivial>>::value, "");
+static_assert(std::is_trivially_destructible<
+              observer_ptr<nontrivial>>::value, "");
+
+static_assert(std::is_constructible<
+              observer_ptr<nontrivial>, nontrivial*>::value,
+              "");
+static_assert(std::is_constructible<observer_ptr<base>, base*>::value, "");
+static_assert(std::is_constructible<observer_ptr<base>, derived*>::value, "");
+static_assert(!std::is_constructible<observer_ptr<base>, other*>::value, "");
+static_assert(std::is_constructible<
+                observer_ptr<base>, observer_ptr<base>>::value, "");
+static_assert(std::is_constructible<
+                observer_ptr<base>, observer_ptr<derived>>::value, "");
+static_assert(!std::is_constructible<
+                observer_ptr<base>, observer_ptr<other>>::value, "");
+
+static_assert(!std::is_assignable<
+              observer_ptr<nontrivial>, nontrivial*>::value,
+              "");
+static_assert(std::is_assignable<
+              observer_ptr<nontrivial>, observer_ptr<nontrivial>>::value,
+              "");
+static_assert(std::is_assignable<observer_ptr<base>, 
+              observer_ptr<base>>::value, "");
+static_assert(std::is_assignable<observer_ptr<base>, 
+              observer_ptr<derived>>::value, "");
+static_assert(!std::is_assignable<
+                observer_ptr<base>, observer_ptr<other>>::value, "");
+static_assert(std::is_assignable<observer_ptr<const int>, 
+              observer_ptr<int>>::value, "");
+static_assert(!std::is_assignable<observer_ptr<int>, 
+              observer_ptr<const int>>::value, "");
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/swap/swap.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/swap/swap.cc
new file mode 100644
index 0000000..f7bfc2d
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/swap/swap.cc
@@ -0,0 +1,67 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do run }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+#include <testsuite_hooks.h>
+
+using std::experimental::observer_ptr;
+
+struct B {};
+struct D : B {};
+
+void test01()
+{
+  observer_ptr<int> a, b;
+  VERIFY(a == b);
+  swap(a, b);
+  VERIFY(a == b);
+}
+
+void test02()
+{
+  int x{};
+  observer_ptr<int> a;
+  observer_ptr<int> b{&x};
+  VERIFY(!a);
+  VERIFY(b);
+  swap(a, b);
+  VERIFY(a);
+  VERIFY(!b);
+}
+
+void test03()
+{
+  int x[2]{1,2};
+  observer_ptr<int> a{&x[0]};
+  observer_ptr<int> b{&x[1]};
+  VERIFY(*a == 1);
+  VERIFY(*b == 2);
+  swap(a, b);
+  VERIFY(*a == 2);
+  VERIFY(*b == 1);
+}
+
+
+int main()
+{
+  test01();
+  test02();
+  test03();
+}
diff --git a/libstdc++-v3/testsuite/experimental/memory/observer_ptr/typedefs.cc b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/typedefs.cc
new file mode 100644
index 0000000..b738232
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/memory/observer_ptr/typedefs.cc
@@ -0,0 +1,32 @@
+// { dg-options "-std=gnu++14" }
+// { dg-do compile }
+
+// Copyright (C) 2015 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.
+
+// You should have received a moved_to of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <experimental/memory>
+#include <type_traits>
+
+static_assert(std::is_same<
+              std::experimental::observer_ptr<int>::element_type,
+              int>::value, "");
+static_assert(std::is_same<
+              std::experimental::observer_ptr<const int>::element_type,
+              const int>::value, "");
+static_assert(std::is_same<
+              std::experimental::observer_ptr<volatile int>::element_type,
+              volatile int>::value, "");

Re: [libstdc++ PATCH] Implement observer_ptr

[Jonathan Wakely]

[-- Attachment #1: Type: text/plain, Size: 280 bytes --]

On 01/05/15 16:37 +0300, Ville Voutilainen wrote:
>Tested on Linux-x64.
>
>    Implement observer_ptr.

Thanks! Committed with some minor formatting changes.

I've also committed this to add feature-test macros and update the
docs. Tested powerpc64le-linux, committed to trunk.



[-- Attachment #2: patch.txt --]
[-- Type: text/x-patch, Size: 1973 bytes --]

commit 2606fe20721608c2d6f6c95f1748e53640796745
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Fri May 1 21:51:48 2015 +0100

    	* include/experimental/memory: Add feature-test macro.
    	* include/experimental/vector: Likewise.
    	* doc/xml/manual/status_cxx2017.xml: Update status.
    	* doc/html/manual/status.html: Regenerate.

diff --git a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
index b08e1b1..80dd050 100644
--- a/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
+++ b/libstdc++-v3/doc/xml/manual/status_cxx2017.xml
@@ -233,14 +233,13 @@ not in any particular release.
     </row>
 
     <row>
-      <?dbhtml bgcolor="#C8B0B0" ?>
       <entry>
 	<link xmlns:xlink="http://www.w3.org/1999/xlink" xlink:href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4282.pdf">
 	  N4282
 	</link>
       </entry>
       <entry>The World's Dumbest Smart Pointer</entry>
-      <entry>N</entry>
+      <entry>Y</entry>
       <entry>Library Fundamentals 2 TS</entry>
     </row>
 
diff --git a/libstdc++-v3/include/experimental/memory b/libstdc++-v3/include/experimental/memory
index d3c9509..f43621f 100644
--- a/libstdc++-v3/include/experimental/memory
+++ b/libstdc++-v3/include/experimental/memory
@@ -52,6 +52,8 @@ inline namespace fundamentals_v2
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
+#define __cpp_lib_experimental_not_fn 201411
+
   template <typename _Tp>
     class observer_ptr
     {
diff --git a/libstdc++-v3/include/experimental/vector b/libstdc++-v3/include/experimental/vector
index 245e034..37645a1 100644
--- a/libstdc++-v3/include/experimental/vector
+++ b/libstdc++-v3/include/experimental/vector
@@ -46,6 +46,8 @@ inline namespace fundamentals_v2
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
+#define __cpp_lib_experimental_erase_if 201411
+
   template<typename _Tp, typename _Alloc, typename _Predicate>
     inline void
     erase_if(vector<_Tp, _Alloc>& __cont, _Predicate __pred)

Re: [libstdc++ PATCH] Implement observer_ptr

[Jonathan Wakely]

[-- Attachment #1: Type: text/plain, Size: 422 bytes --]

On 01/05/15 22:01 +0100, Jonathan Wakely wrote:
>On 01/05/15 16:37 +0300, Ville Voutilainen wrote:
>>Tested on Linux-x64.
>>
>>   Implement observer_ptr.
>
>Thanks! Committed with some minor formatting changes.
>
>I've also committed this to add feature-test macros and update the
>docs. Tested powerpc64le-linux, committed to trunk.

Thanks to Ville for pointing out that I put the wrong macro. Doh.

Committed to trunk.

[-- Attachment #2: patch.txt --]
[-- Type: text/x-patch, Size: 659 bytes --]

commit f6fdadce0e8362d8ccaf0bdf024e1d9ac73afeaa
Author: Jonathan Wakely <jwakely@redhat.com>
Date:   Fri May 1 22:22:19 2015 +0100

    	* include/experimental/memory: Correct feature-test macro.

diff --git a/libstdc++-v3/include/experimental/memory b/libstdc++-v3/include/experimental/memory
index f43621f..08a6b33 100644
--- a/libstdc++-v3/include/experimental/memory
+++ b/libstdc++-v3/include/experimental/memory
@@ -52,7 +52,7 @@ inline namespace fundamentals_v2
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
-#define __cpp_lib_experimental_not_fn 201411
+#define __cpp_lib_experimental_observer_ptr 201411
 
   template <typename _Tp>
     class observer_ptr

Re: [libstdc++ PATCH] Implement observer_ptr

[Ed Smith-Rowland]

On 05/01/2015 05:01 PM, Jonathan Wakely wrote:
> On 01/05/15 16:37 +0300, Ville Voutilainen wrote:
>> Tested on Linux-x64.
>>
>>    Implement observer_ptr.
>
> Thanks! Committed with some minor formatting changes.
>
> I've also committed this to add feature-test macros and update the
> docs. Tested powerpc64le-linux, committed to trunk.
>
>
I pretty sure we're supposed to add the macro for *all* the headers that 
got enable_if.

I actually went ahead and did this on 222713.

2015-05-02  Edward Smith-Rowland  <3dw4rd@verizon.net>

     * include/experimental/deque: Add feature-test macro.
     * include/experimental/forward_list: Ditto.
     * include/experimental/list: Ditto.
     * include/experimental/map: Ditto.
     * include/experimental/set: Ditto.
     * include/experimental/string: Ditto.
     * include/experimental/unordered_map: Ditto.
     * include/experimental/unordered_set: Ditto.

Re: [libstdc++ PATCH] Implement observer_ptr

[Jonathan Wakely]

On 01/05/15 22:02 -0400, Ed Smith-Rowland wrote:
>On 05/01/2015 05:01 PM, Jonathan Wakely wrote:
>>On 01/05/15 16:37 +0300, Ville Voutilainen wrote:
>>>Tested on Linux-x64.
>>>
>>>   Implement observer_ptr.
>>
>>Thanks! Committed with some minor formatting changes.
>>
>>I've also committed this to add feature-test macros and update the
>>docs. Tested powerpc64le-linux, committed to trunk.
>>
>>
>I pretty sure we're supposed to add the macro for *all* the headers 
>that got enable_if.

That's not how I read the Fundamentals TS:

  Programmers who wish to determine whether a feature is available in
  an implementation should base that determination on the presence of
  the header (determined with __has_include(<header/name>)) and the
  state of the macro with the recommended name.

And the header for erase_if is listed as <experimental/vector>.

Re: [libstdc++ PATCH] Implement observer_ptr

[Jonathan Wakely]

On 02/05/15 10:40 +0100, Jonathan Wakely wrote:
>On 01/05/15 22:02 -0400, Ed Smith-Rowland wrote:
>>On 05/01/2015 05:01 PM, Jonathan Wakely wrote:
>>>On 01/05/15 16:37 +0300, Ville Voutilainen wrote:
>>>>Tested on Linux-x64.
>>>>
>>>>  Implement observer_ptr.
>>>
>>>Thanks! Committed with some minor formatting changes.
>>>
>>>I've also committed this to add feature-test macros and update the
>>>docs. Tested powerpc64le-linux, committed to trunk.
>>>
>>>
>>I pretty sure we're supposed to add the macro for *all* the headers 
>>that got enable_if.
>
>That's not how I read the Fundamentals TS:
>
> Programmers who wish to determine whether a feature is available in
> an implementation should base that determination on the presence of
> the header (determined with __has_include(<header/name>)) and the
> state of the macro with the recommended name.
>
>And the header for erase_if is listed as <experimental/vector>.


And SD-6 says:

  For library features, the “Header“ column identifies the header that
  is expected to define the macro, although the macro may also be
  predefined.

Re: [libstdc++ PATCH] Implement observer_ptr

[Ed Smith-Rowland]

On 05/02/2015 05:42 AM, Jonathan Wakely wrote:
> On 02/05/15 10:40 +0100, Jonathan Wakely wrote:
>> On 01/05/15 22:02 -0400, Ed Smith-Rowland wrote:
>>> On 05/01/2015 05:01 PM, Jonathan Wakely wrote:
>>>> On 01/05/15 16:37 +0300, Ville Voutilainen wrote:
>>>>> Tested on Linux-x64.
>>>>>
>>>>>  Implement observer_ptr.
>>>>
>>>> Thanks! Committed with some minor formatting changes.
>>>>
>>>> I've also committed this to add feature-test macros and update the
>>>> docs. Tested powerpc64le-linux, committed to trunk.
>>>>
>>>>
>>> I pretty sure we're supposed to add the macro for *all* the headers 
>>> that got enable_if.
>>
>> That's not how I read the Fundamentals TS:
>>
>> Programmers who wish to determine whether a feature is available in
>> an implementation should base that determination on the presence of
>> the header (determined with __has_include(<header/name>)) and the
>> state of the macro with the recommended name.
>>
>> And the header for erase_if is listed as <experimental/vector>.
>
>
> And SD-6 says:
>
>  For library features, the “Header“ column identifies the header that
>  is expected to define the macro, although the macro may also be
>  predefined.
>
>
>
OK.  Thanks.

I do remember an SD-6 discussion about how annoying the 
define-the-macro-in-all-relevant-headers was.
I didn't know there was a resolution.  I need to reeducate myself.
Meanwhile I'll rollback my patch.

Reverted in 222722.

I'll ask next time.
Sorry for the noise.

Ed

Re: [libstdc++ PATCH] Implement observer_ptr

[Jonathan Wakely]

On 02/05/15 08:49 -0400, Ed Smith-Rowland wrote:
>OK.  Thanks.
>
>I do remember an SD-6 discussion about how annoying the 
>define-the-macro-in-all-relevant-headers was.
>I didn't know there was a resolution.  I need to reeducate myself.
>Meanwhile I'll rollback my patch.
>
>Reverted in 222722.
>
>I'll ask next time.
>Sorry for the noise.

OK, no problem. I wasn't going to ask you to revert it, as it didn't
really do any harm, I just don't think it is required to be in every
header.

I've been wondering if it would be better to just put all the
feature-test macros in a central place, like <bits/c++config.h> (and
maybe somewhre separate for the "experimental" ones). Stephen Kelly's
complaints about Boost having to include loads of large std::lib
headers to test the macros is a valid complaint about the current SD-6
scheme.

I *think* that would also still be conforming, because the macro would
be defined when you include the right header ... it would just be
defined when you include any other headers too :-)