add virtual_any

virtual_any<Any, Registry> is to `any` what virtual_ptr is to a pointer:
it combines an `any` - held by value - with the v-table pointer for the
contained value, so methods dispatch on the contained type without
looking it up on every call. The v-table pointer is acquired at
construction: from the dynamic type of an existing `any` (a hash table
lookup via virtual_traits<const Any&>::vptr), or statically when the
contained type is known (the value constructor, emplace, and the
make_*_virtual factories use static_vptr, like make_unique_virtual).
Assignment and emplace re-derive it, and no mutable accessor to the
`any` is exposed, so the vptr always matches the payload.

Methods take virtual_any by const, mutable or rvalue reference;
overriders receive the contained type by a reference of a compatible
category - the casts delegate to the existing virtual_traits<Any cvref>
specializations - or the virtual_any itself, unchanged, for a catch-all
overrider. Passing virtual_any by value is rejected: it would copy the
payload on every call. The value constructor makes overrider parameters
convertible to the method's, so BOOST_OPENMETHOD_OVERRIDE locates
virtual_any methods; the mutable lvalue case still needs
method<...>::override<Fn>, as with virtual_<Any&>.

No changes to core.hpp: dispatch reads the stored vptr through the
boost_openmethod_vptr hook (a friend, so ADL only finds it when a
virtual_any is an argument), and the detail templates (is_virtual,
parameter_traits, validate_method_parameter, validate_overrider_parameter,
select_overrider_virtual_type_aux) are specialized on the concrete class.
The exact-pair validate_overrider_parameter specializations disambiguate
with the generic <T, T> one, which partial ordering ranks neither above
nor below <virtual_any cvref, T2>.

The class is generic: it only requires virtual_traits<Any cvref> with
vptr and cast, so it serves std::any, boost::any, and future any-likes.
std_any.hpp and boost_any.hpp provide the default-registry aliases
virtual_std_any and virtual_boost_any and the make_std_any_virtual and
make_boost_any_virtual factories. They also delete the final_virtual_ptr
overloads for their `any` type: the primary template would silently use
static_vptr<any> - the v-table of the `any` root class, not of the
contained value.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: jll63

doc/modules/ROOT/pages/ref_headers.adoc

@@ -71,21 +71,43 @@ Provides a `virtual_traits` specialization that makes it possible to use a
 Provides a `virtual_traits` specialization that makes it possible to use a
 `boost::intrusive_ptr` in place of a raw pointer or reference in virtual parameters.
 
+[#virtual_any]
+### link:{{BASE_URL}}/include/boost/openmethod/interop/virtual_any.hpp[<boost/openmethod/interop/virtual_any.hpp>]
+
+Provides `virtual_any`, a wide `any` that combines an `any`, held by value,
+with a pointer to the v-table for the contained value - like `virtual_ptr`
+combines a pointer to an object with a pointer to its v-table. The v-table
+pointer is acquired when the `virtual_any` is created, so methods dispatch on
+the contained type without looking it up on every call. Also provides
+`make_any_virtual`, which creates a `virtual_any` containing a value of a
+statically known type, setting the v-table pointer without any lookup. This
+header is included by `std_any.hpp` and `boost_any.hpp`; it can serve any type
+with an `any`-like interface, given `virtual_traits` specializations for its
+reference types.
+
 [#std_any]
 ### link:{{BASE_URL}}/include/boost/openmethod/interop/std_any.hpp[<boost/openmethod/interop/std_any.hpp>]
 
 Provides `virtual_traits` specializations that make it possible to use a `std::any` -
 by const reference, by mutable reference, or by rvalue reference - in virtual
 parameters. Dispatch is on the type of the contained value. Also provides
-`use_std_any_types`, which registers the types that may be contained.
+`use_std_any_types`, which registers the types that may be contained;
+`virtual_std_any`, an alias for `virtual_any<std::any>`, and
+`make_std_any_virtual`. In addition, the header deletes the
+`final_virtual_ptr` overloads for `std::any`, which would otherwise silently
+use the v-table of the `any` root class instead of the contained value's.
 
 [#boost_any]
 ### link:{{BASE_URL}}/include/boost/openmethod/interop/boost_any.hpp[<boost/openmethod/interop/boost_any.hpp>]
 
 Provides `virtual_traits` specializations that make it possible to use a `boost::any` -
 by const reference, by mutable reference, or by rvalue reference - in virtual
 parameters. Dispatch is on the type of the contained value. Also provides
-`use_boost_any_types`, which registers the types that may be contained.
+`use_boost_any_types`, which registers the types that may be contained;
+`virtual_boost_any`, an alias for `virtual_any<boost::any>`, and
+`make_boost_any_virtual`. In addition, the header deletes the
+`final_virtual_ptr` overloads for `boost::any`, which would otherwise silently
+use the v-table of the `any` root class instead of the contained value's.
 
 *The headers below are for advanced use*.
 

include/boost/openmethod/interop/boost_any.hpp

@@ -8,6 +8,7 @@
 
 #include <boost/any.hpp>
 #include <boost/openmethod/core.hpp>
+#include <boost/openmethod/interop/virtual_any.hpp>
 
 namespace boost::openmethod {
 
@@ -238,6 +239,57 @@ struct use_boost_any_types
           typename detail::extract_registry<T...>::registry,
           mp11::mp_list<T, boost::any>>... {};
 
+//! Alias for a `virtual_any<boost::any>`, in the default registry.
+//!
+//! With another registry, use `virtual_any<boost::any, Registry>` directly.
+using virtual_boost_any = virtual_any<boost::any>;
+
+//! Create a new object and return a `virtual_boost_any` containing it.
+//!
+//! Create a `Class` from `args`, store it in a `boost::any`, and return a
+//! @ref virtual_any with its v-table pointer set to the
+//! @ref registry::static_vptr for `Class` - no hash table lookup is
+//! involved.
+//!
+//! @tparam Class The type of the value to create.
+//! @tparam Registry A @ref registry.
+//! @tparam T Types of the arguments to pass to the constructor of
+//! `Class`.
+//! @param args Arguments to pass to the constructor of `Class`.
+//! @return A `virtual_any<boost::any, Registry>` containing a newly created
+//! `Class`.
+template<
+    class Class, class Registry = BOOST_OPENMETHOD_DEFAULT_REGISTRY,
+    typename... T>
+inline auto
+make_boost_any_virtual(T&&... args) -> virtual_any<boost::any, Registry> {
+    return make_any_virtual<Class, boost::any, Registry>(
+        std::forward<T>(args)...);
+}
+
+// The primary final_virtual_ptr would silently use static_vptr<boost::any>
+// - the v-table of the `any` root class, not of the contained value.
+// Delete the combination. Both call forms need covering: the non-template
+// overloads catch calls that deduce the default registry, and are removed
+// from consideration when an explicit template argument list is given, so
+// the Registry-only templates - more specialized than the primary - catch
+// those.
+
+template<class Registry>
+void final_virtual_ptr(const boost::any&) = delete;
+template<class Registry>
+void final_virtual_ptr(boost::any&) = delete;
+template<class Registry>
+void final_virtual_ptr(boost::any&&) = delete;
+void final_virtual_ptr(const boost::any&) = delete;
+void final_virtual_ptr(boost::any&) = delete;
+void final_virtual_ptr(boost::any&&) = delete;
+
+namespace aliases {
+using boost::openmethod::make_boost_any_virtual;
+using boost::openmethod::virtual_boost_any;
+} // namespace aliases
+
 } // namespace boost::openmethod
 
 #endif

include/boost/openmethod/interop/std_any.hpp

@@ -8,6 +8,7 @@
 
 #include <any>
 #include <boost/openmethod/core.hpp>
+#include <boost/openmethod/interop/virtual_any.hpp>
 
 namespace boost::openmethod {
 
@@ -201,6 +202,57 @@ struct use_std_any_types
           typename detail::extract_registry<T...>::registry,
           mp11::mp_list<T, std::any>>... {};
 
+//! Alias for a `virtual_any<std::any>`, in the default registry.
+//!
+//! With another registry, use `virtual_any<std::any, Registry>` directly.
+using virtual_std_any = virtual_any<std::any>;
+
+//! Create a new object and return a `virtual_std_any` containing it.
+//!
+//! Create a `Class` from `args`, store it in a `std::any`, and return a
+//! @ref virtual_any with its v-table pointer set to the
+//! @ref registry::static_vptr for `Class` - no hash table lookup is
+//! involved.
+//!
+//! @tparam Class The type of the value to create.
+//! @tparam Registry A @ref registry.
+//! @tparam T Types of the arguments to pass to the constructor of
+//! `Class`.
+//! @param args Arguments to pass to the constructor of `Class`.
+//! @return A `virtual_any<std::any, Registry>` containing a newly created
+//! `Class`.
+template<
+    class Class, class Registry = BOOST_OPENMETHOD_DEFAULT_REGISTRY,
+    typename... T>
+inline auto
+make_std_any_virtual(T&&... args) -> virtual_any<std::any, Registry> {
+    return make_any_virtual<Class, std::any, Registry>(
+        std::forward<T>(args)...);
+}
+
+// The primary final_virtual_ptr would silently use static_vptr<std::any>
+// - the v-table of the `any` root class, not of the contained value.
+// Delete the combination. Both call forms need covering: the non-template
+// overloads catch calls that deduce the default registry, and are removed
+// from consideration when an explicit template argument list is given, so
+// the Registry-only templates - more specialized than the primary - catch
+// those.
+
+template<class Registry>
+void final_virtual_ptr(const std::any&) = delete;
+template<class Registry>
+void final_virtual_ptr(std::any&) = delete;
+template<class Registry>
+void final_virtual_ptr(std::any&&) = delete;
+void final_virtual_ptr(const std::any&) = delete;
+void final_virtual_ptr(std::any&) = delete;
+void final_virtual_ptr(std::any&&) = delete;
+
+namespace aliases {
+using boost::openmethod::make_std_any_virtual;
+using boost::openmethod::virtual_std_any;
+} // namespace aliases
+
 } // namespace boost::openmethod
 
 #endif