Added casting constructor from owner for basic_observer_ptr for #12

Author: cschreib

include/oup/observable_unique_ptr.hpp

@@ -986,6 +986,26 @@ class basic_observer_ptr final {
         }
     }
 
+    /**
+     * \brief Create an observer pointer from an owning pointer of a different type.
+     * \param manager The owner pointer to copy the observed data from
+     * \param value The casted pointer value to observe
+     * \note The raw pointer `value` may or may not be related to the raw pointer
+     * owner by `manager`. This could be a pointer to any other object which is known
+     * to have the same lifetime.
+     */
+    template<
+        typename U,
+        typename D,
+        typename P,
+        typename enable = std::enable_if_t<std::is_same_v<Policy, typename P::observer_policy>>>
+    basic_observer_ptr(const basic_observable_ptr<U, D, P>& manager, T* value) noexcept :
+        block(manager.block), data(value) {
+        if (block) {
+            block->push_ref();
+        }
+    }
+
     /**
      * \brief Copy an existing @ref basic_observer_ptr instance
      * \param value The existing observer pointer to copy

tests/runtime_tests.cpp

@@ -1949,6 +1949,94 @@ TEST_CASE("observer explicit conversion copy constructor subobject", "[observer_
     REQUIRE(mem_track.double_del() == 0u);
 }
 
+TEST_CASE("observer from null owner constructor", "[observer_construction]") {
+    memory_tracker mem_track;
+
+    {
+        test_ptr ptr_owner;
+        {
+            test_optr ptr{ptr_owner};
+            REQUIRE(instances == 0);
+            REQUIRE(ptr.get() == ptr_owner.get());
+            REQUIRE(ptr.expired() == true);
+        }
+
+        REQUIRE(instances == 0);
+    }
+
+    REQUIRE(instances == 0);
+    REQUIRE(mem_track.leaks() == 0u);
+    REQUIRE(mem_track.double_del() == 0u);
+}
+
+TEST_CASE("observer from owner constructor", "[observer_construction]") {
+    memory_tracker mem_track;
+
+    {
+        test_ptr ptr_owner{new test_object};
+        {
+            test_optr ptr{ptr_owner};
+            REQUIRE(instances == 1);
+            REQUIRE(ptr.get() == ptr_owner.get());
+            REQUIRE(ptr.expired() == false);
+
+            ptr_owner.reset();
+            REQUIRE(ptr.get() == nullptr);
+            REQUIRE(ptr.expired() == true);
+        }
+
+        REQUIRE(instances == 0);
+    }
+
+    REQUIRE(instances == 0);
+    REQUIRE(mem_track.leaks() == 0u);
+    REQUIRE(mem_track.double_del() == 0u);
+}
+
+TEST_CASE("observer from null owner casting constructor", "[observer_construction]") {
+    memory_tracker mem_track;
+
+    {
+        test_ptr ptr_owner;
+        {
+            test_optr ptr{ptr_owner, static_cast<test_object*>(nullptr)};
+            REQUIRE(instances == 0);
+            REQUIRE(ptr.get() == ptr_owner.get());
+            REQUIRE(ptr.expired() == true);
+        }
+
+        REQUIRE(instances == 0);
+    }
+
+    REQUIRE(instances == 0);
+    REQUIRE(mem_track.leaks() == 0u);
+    REQUIRE(mem_track.double_del() == 0u);
+}
+
+TEST_CASE("observer from owner casting constructor", "[observer_construction]") {
+    memory_tracker mem_track;
+
+    {
+        test_ptr ptr_owner{new test_object_derived};
+        {
+            test_optr ptr{ptr_owner, dynamic_cast<test_object_derived*>(ptr_owner.get())};
+            REQUIRE(instances == 1);
+            REQUIRE(ptr.get() == ptr_owner.get());
+            REQUIRE(ptr.expired() == false);
+
+            ptr_owner.reset();
+            REQUIRE(ptr.get() == nullptr);
+            REQUIRE(ptr.expired() == true);
+        }
+
+        REQUIRE(instances == 0);
+    }
+
+    REQUIRE(instances == 0);
+    REQUIRE(mem_track.leaks() == 0u);
+    REQUIRE(mem_track.double_del() == 0u);
+}
+
 TEST_CASE("observer move constructor", "[observer_construction]") {
     memory_tracker mem_track;