From eee99d4116ca122867c6af914a439133a6fdc4af Mon Sep 17 00:00:00 2001
From: Pavel Emelyanov <xemul@scylladb.com>
Date: Tue, 7 May 2024 12:56:05 +0300
Subject: [PATCH] weak_ptr: Make it possible to convert to "compatible"
 pointers

The patch introduces weak_ptr<T>(weak_ptr<Y>&&) constructor that creates
weak_ptr<T> out of convertible to T* Y's. This has two implications.

First, the main one, is that it's no possible to obtain a constant weak
pointer on an object.

Another, a nice side effect, is: given a base-class we can now create
weak_ptr<base> out of weak_ptr<inherited>.

Signed-off-by: Pavel Emelyanov <xemul@scylladb.com>
---
 include/seastar/core/weak_ptr.hh | 17 +++++++++++++++++
 tests/unit/weak_ptr_test.cc      | 27 +++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/include/seastar/core/weak_ptr.hh b/include/seastar/core/weak_ptr.hh
index f73d936efed..98fe32d96a3 100644
--- a/include/seastar/core/weak_ptr.hh
+++ b/include/seastar/core/weak_ptr.hh
@@ -46,6 +46,8 @@ template<typename T>
 class weak_ptr {
     template<typename U>
     friend class weakly_referencable;
+    template <typename U>
+    friend class weak_ptr;
 private:
     using hook_type = boost::intrusive::list_member_hook<boost::intrusive::link_mode<boost::intrusive::auto_unlink>>;
     hook_type _hook;
@@ -59,7 +61,18 @@ private:
         _hook.swap_nodes(o._hook);
         std::swap(_ptr, o._ptr);
     }
+
 public:
+    template <typename U>
+    requires std::convertible_to<U*, T*>
+    weak_ptr(weak_ptr<U>&& o)
+    {
+        if (o._ptr) {
+            _ptr = std::exchange(o._ptr, nullptr);
+            _hook.swap_nodes(o._hook);
+        }
+    }
+
     // Note: The default constructor's body is implemented as no-op
     // rather than `noexcept = default` due to a bug with gcc 9.3.1
     // that deletes the constructor since boost::intrusive::list_member_hook
@@ -139,6 +152,10 @@ public:
         _ptr_list.push_back(ptr);
         return ptr;
     }
+
+    weak_ptr<const T> weak_from_this() const noexcept {
+        return const_cast<weakly_referencable*>(this)->weak_from_this();
+    }
 };
 
 }
diff --git a/tests/unit/weak_ptr_test.cc b/tests/unit/weak_ptr_test.cc
index 5929a2a60a6..7d2f863f129 100644
--- a/tests/unit/weak_ptr_test.cc
+++ b/tests/unit/weak_ptr_test.cc
@@ -48,6 +48,33 @@ BOOST_AUTO_TEST_CASE(test_weak_ptr_is_reset) {
     BOOST_REQUIRE(!bool(wp));
 }
 
+BOOST_AUTO_TEST_CASE(test_const_weak_ptr) {
+    auto owning_ptr = std::make_unique<myclass>();
+
+    weak_ptr<const myclass> cwptr = const_cast<const myclass&>(*owning_ptr).weak_from_this();
+    BOOST_REQUIRE(bool(cwptr));
+    owning_ptr.reset();
+    BOOST_REQUIRE(!bool(cwptr));
+}
+
+class baseclass {};
+class myiclass : public baseclass, public weakly_referencable<myiclass> {};
+
+BOOST_AUTO_TEST_CASE(test_base_class_weak_ptr) {
+    auto owning_ptr = std::make_unique<myiclass>();
+
+    auto get_checker = [] (weak_ptr<baseclass> p) {
+        return [p = std::move(p)] (bool v) {
+            BOOST_REQUIRE_EQUAL(bool(p), v);
+        };
+    };
+
+    auto checker = get_checker(owning_ptr->weak_from_this());
+    checker(true);
+    owning_ptr.reset();
+    checker(false);
+}
+
 BOOST_AUTO_TEST_CASE(test_weak_ptr_can_be_moved) {
     auto owning_ptr = std::make_unique<myclass>();
     weak_ptr<myclass> wp1 = owning_ptr->weak_from_this();