wip

Author: jll63

include/boost/openmethod/core.hpp

@@ -720,83 +720,63 @@ class virtual_ptr {
 
     //! Construct a `virtual_ptr` from another `virtual_ptr`
     //!
-    //! Copy the object and v-table pointers from `other` to `this`.
+    //! Copy the object and v-table pointers from `other` to `this.
     //!
-    //! @param other A virtual_ptr to a type-compatible object
+    //! `Other` is _not_ required to be a pointer to a polymorphic class.
+    //!
+    //! @par Examples
+    //!
+    //! Assigning from a plain virtual_ptr:
     //!
-    //! @par Example
     //! @code
     //! struct Animal {}; // polymorphism not required
     //! struct Dog : Animal {}; // polymorphism not required
     //! BOOST_OPENMETHOD_CLASSES(Animal, Dog);
     //! initialize();
     //!
     //! Dog snoopy;
-    //! const virtual_ptr<Dog> dog = final_virtual_ptr(snoopy);
+    //! virtual_ptr<Dog> dog = final_virtual_ptr(snoopy);
+    //! virtual_ptr<Animal> p{nullptr};
     //!
-    //! virtual_ptr<Animal> p(dog);
+    //! p = dog;
     //!
     //! BOOST_TEST(p.get() == &snoopy);
     //! BOOST_TEST(p.vptr() == default_registry::static_vptr<Dog>);
     //! @endcode
     //!
-    //! @par Requirements
-    //!
-    //! @li `Other\*` must be constructible from `Class\*`.
-    template<
-        class Other,
-        typename = std::enable_if_t<std::is_constructible_v<
-            Class*, typename virtual_ptr<Other, Registry>::element_type*>>>
-    virtual_ptr(const virtual_ptr<Other, Registry>& other)
-        : vp(other.vp), obj(other.get()) {
-    }
-
-    //! Construct a `virtual_ptr` from another `virtual_ptr`
-    //!
-    //! Copy the object and v-table pointers from `other` to `this`.
-    //!
-    //! A plain `virtual_ptr` can be constructed from a smart virtual_ptr, as
-    //! long as the smart pointer's element type is convertible to the plain
-    //! pointer's element type.
-    //!
-    //! `Other::element_type` is _not_ required to be a pointer to a polymorphic
-    //! class.
+    //! Assigning from a smart virtual_ptr:
     //!
-    //! @par Example
     //! @code
     //! struct Animal {}; // polymorphism not required
     //! struct Dog : Animal {}; // polymorphism not required
     //! BOOST_OPENMETHOD_CLASSES(Animal, Dog);
     //! initialize();
     //!
-    //! Dog snoopy;
-    //! virtual_ptr<Dog> dog = final_virtual_ptr(snoopy);
-    //!
-    //! virtual_ptr<Animal> p(dog);
+    //! virtual_ptr<std::shared_ptr<Animal>> snoopy = make_shared_virtual<Dog>();
+    //! virtual_ptr<Animal> p = snoopy;
     //!
-    //! BOOST_TEST(p.get() == &snoopy);
+    //! BOOST_TEST(p.get() == snoopy.get());
     //! BOOST_TEST(p.vptr() == default_registry::static_vptr<Dog>);
     //! @endcode
     //!
+    //! No construction of a smart `virtual_ptr` from a plain `virtual_ptr`:
+    //!
+    //! @code
+    //! static_assert(
+    //!     std::is_constructible_v<
+    //!         shared_virtual_ptr<Animal>, virtual_ptr<Dog>> == false);
+    //! @endcode
+    //!
     //! @param other A virtual_ptr to a type-compatible object
     //!
     //! @par Requirements
-    //!
-    //! @li `Other\*` must be constructible from `Class\*`.
+    //! @li `Other`\'s object pointer must be assignable to a `Class\*`.
     template<
         class Other,
         typename = std::enable_if_t<std::is_constructible_v<
             Class*, typename virtual_ptr<Other, Registry>::element_type*>>>
-    virtual_ptr(virtual_ptr<Other, Registry>& other)
+    virtual_ptr(const virtual_ptr<Other, Registry>& other)
         : vp(other.vp), obj(other.get()) {
-        // Why is this needed? Consider this conversion conversion from
-        // smart to dumb pointer:
-        //      virtual_ptr<std::shared_ptr<const Node>> p = ...;
-        //      virtual_ptr<const Node> q = p;
-        // Since 'p' is not const, in the absence of this ctor,
-        // virtual_ptr(Other&) would be preferred to
-        // virtual_ptr(const virtual_ptr<Other, Registry>& other), and
-        // that is incorrect.
     }
 
     //! Assign a `virtual_ptr` from a reference to an object
@@ -843,7 +823,7 @@ class virtual_ptr {
         typename = std::enable_if_t<
             BOOST_OPENMETHOD_DETAIL_UNLESS_MRDOCS
                 IsPolymorphic<Class, Registry> &&
-            std::is_assignable_v<Class*, Other*>>>
+            std::is_assignable_v<Class*&, Other*>>>
     virtual_ptr& operator=(Other& other) {
         obj = &other;
         vp = detail::box_vptr<use_indirect_vptrs>(
@@ -893,7 +873,7 @@ class virtual_ptr {
         typename = std::enable_if_t<
             BOOST_OPENMETHOD_DETAIL_UNLESS_MRDOCS
                 IsPolymorphic<Class, Registry> &&
-            std::is_assignable_v<Class*, Other*>>>
+            std::is_assignable_v<Class*&, Other*>>>
     virtual_ptr& operator=(Other* other) {
         obj = other;
         vp = detail::box_vptr<use_indirect_vptrs>(
@@ -903,11 +883,14 @@ class virtual_ptr {
 
     //! Assign a `virtual_ptr` from another `virtual_ptr`
     //!
-    //! The pointer to the v-table is copied from `other`.
+    //! Copy the object and v-table pointers from `other` to `this.
     //!
     //! `Other` is _not_ required to be a pointer to a polymorphic class.
     //!
-    //! @par Example
+    //! @par Examples
+    //!
+    //! Assigning from a plain virtual_ptr:
+    //!
     //! @code
     //! struct Animal {}; // polymorphism not required
     //! struct Dog : Animal {}; // polymorphism not required
@@ -924,14 +907,39 @@ class virtual_ptr {
     //! BOOST_TEST(p.vptr() == default_registry::static_vptr<Dog>);
     //! @endcode
     //!
-    //! @param other A virtual_ptr to a type-compatible polymorphic object
+    //! Assigning from a smart virtual_ptr:
+    //!
+    //! @code
+    //! struct Animal {}; // polymorphism not required
+    //! struct Dog : Animal {}; // polymorphism not required
+    //! BOOST_OPENMETHOD_CLASSES(Animal, Dog);
+    //! initialize();
+    //!
+    //! virtual_ptr<std::shared_ptr<Animal>> snoopy = make_shared_virtual<Dog>();
+    //! virtual_ptr<Animal> p;
+    //!
+    //! p = snoopy;
+    //!
+    //! BOOST_TEST(p.get() == snoopy.get());
+    //! BOOST_TEST(p.vptr() == default_registry::static_vptr<Dog>);
+    //! @endcode
+    //!
+    //! No assignment from a plain `virtual_ptr` to a smart `virtual_ptr`:
+    //!
+    //! @code
+    //! static_assert(
+    //!     std::is_assignable_v<
+    //!         shared_virtual_ptr<Animal>&, virtual_ptr<Dog>> == false);
+    //! @endcode
+    //!
+    //! @param other A virtual_ptr to a type-compatible object
     //!
     //! @par Requirements
-    //! @li `Other\*` must be constructible from `Class\*`.
+    //! @li `Other`\'s object pointer must be assignable to a `Class\*`.
     template<
         class Other,
         typename = std::enable_if_t<std::is_assignable_v<
-            Class*, typename virtual_ptr<Other, Registry>::element_type*>>>
+            Class*&, typename virtual_ptr<Other, Registry>::element_type*>>>
     virtual_ptr& operator=(const virtual_ptr<Other, Registry>& other) {
         obj = other.get();
         vp = other.vp;
@@ -1283,43 +1291,6 @@ class virtual_ptr<
         : vp(other.vp), obj(other.obj) {
     }
 
-    //! Construct from a smart virtual pointer to a derived class
-    //!
-    //! Copy the object and v-table pointers from `other`.
-    //!
-    //! `Other` is _not_ required to be a pointer to a polymorphic class.
-    //!
-    //! @par Example
-    //! @code
-    //! struct Animal {}; // polymorphism not required
-    //! struct Dog : Animal {}; // polymorphism not required
-    //! BOOST_OPENMETHOD_CLASSES(Animal, Dog);
-    //! initialize();
-    //!
-    //! virtual_ptr<std::shared_ptr<Dog>> snoopy = make_shared_virtual<Dog>();
-    //! virtual_ptr<std::shared_ptr<Animal>> p = snoopy;
-    //!
-    //! BOOST_TEST(snoopy.get() != nullptr);
-    //! BOOST_TEST(p.get() == snoopy.get());
-    //! BOOST_TEST(p.vptr() == default_registry::static_vptr<Dog>);
-    //! @endcode
-    //!
-    //! @par Requirements
-    //! @li `SmartPtr` and `Other` must be instantiated from the same template -
-    //! e.g. both `std::shared_ptr` or both `std::unique_ptr`.
-    //! @li `Other` must be a virtual pointer to a class derived from
-    //! `element_type`.
-    //! @li `SmartPtr` must be constructible from `Other&`.
-    template<
-        class Other,
-        typename = std::enable_if_t<
-            BOOST_OPENMETHOD_DETAIL_UNLESS_MRDOCS
-                SameSmartPtr<SmartPtr, Other, Registry> &&
-            std::is_constructible_v<SmartPtr, Other&>>>
-    virtual_ptr(virtual_ptr<Other, Registry>& other)
-        : vp(other.vp), obj(other.obj) {
-    }
-
     //! Construct-move from a virtual pointer to a derived class
     //!
     //! Move the object pointer from `other` to `this`. Copy the v-table pointer