with_vptr -> inplace_vptr

Author: jll63

doc/dynamic_loading.adoc

@@ -8,7 +8,7 @@ called to rebuild the dispatch tables.
 
 This leads to a problem: any `virtual_ptr` in existence before `initialize` is
 called again becomes invalid. This also applies to vptrs that are stored inside
-objects by `with_vptr`.
+objects by `inplace_vptr`.
 
 NOTE: This applies only to cases where a dynamic library adds to an _existing_
 policy. Even if the dynamic library itself uses open-methods, for example as an

doc/html/index.html

@@ -610,7 +610,7 @@ <h1>Boost.OpenMethod</h1>
 <li><a href="#virtual_ptr_description_4">Description</a></li>
 </ul>
 </li>
-<li><a href="#virtual_ptr_with_vptr">with_vptr</a>
+<li><a href="#virtual_ptr_inplace_vptr">inplace_vptr</a>
 <ul class="sectlevel3">
 <li><a href="#virtual_ptr_synopsis_5">Synopsis</a></li>
 <li><a href="#virtual_ptr_description_5">Description</a></li>
@@ -1961,17 +1961,17 @@ <h3 id="tutorials_alternatives_to_virtual_ptr">Alternatives to virtual_ptr</h3>
 </table>
 </div>
 <div class="paragraph">
-<p>The <code>with_vptr</code> CRTP class automates the creation and management of embedded
+<p>The <code>inplace_vptr</code> CRTP class automates the creation and management of embedded
 vptrs.</p>
 </div>
 <div class="listingblock">
 <div class="content">
-<pre class="rouge highlight"><code data-lang="c++">#include &lt;boost/openmethod/with_vptr.hpp&gt;
+<pre class="rouge highlight"><code data-lang="c++">#include &lt;boost/openmethod/inplace_vptr.hpp&gt;
 
-class Animal : public boost::openmethod::with_vptr&lt;Animal&gt; {
+class Animal : public boost::openmethod::inplace_vptr&lt;Animal&gt; {
 };
 
-class Cat : public Animal, public boost::openmethod::with_vptr&lt;Cat, Animal&gt; {
+class Cat : public Animal, public boost::openmethod::inplace_vptr&lt;Cat, Animal&gt; {
 };
 
 BOOST_OPENMETHOD(poke, (std::ostream&amp;, virtual_&lt;Animal&amp;&gt;), void);
@@ -1989,11 +1989,11 @@ <h3 id="tutorials_alternatives_to_virtual_ptr">Alternatives to virtual_ptr</h3>
 </div>
 </div>
 <div class="paragraph">
-<p>If <code>with_vptr</code> is passed only the class being defined, it adds a vptr to it, and
+<p>If <code>inplace_vptr</code> is passed only the class being defined, it adds a vptr to it, and
 defines a <code>boost_openmethod_vptr</code> friend function. If more classes are passed,
 they must be the direct bases of the class potentially involved in open-method
 calls. Its constructor and destructor set the vptr to point to the v-table for
-the class. <code>with_vptr</code> also takes care of registering the classes, so this time
+the class. <code>inplace_vptr</code> also takes care of registering the classes, so this time
 the call to <code>BOOST_OPENMETHOD_CLASSES</code> is not needed.</p>
 </div>
 </div>
@@ -2787,7 +2787,7 @@ <h3 id="tutorials_dynamic_loading">Dynamic Loading</h3>
 <div class="paragraph">
 <p>This leads to a problem: any <code>virtual_ptr</code> in existence before <code>initialize</code> is
 called again becomes invalid. This also applies to vptrs that are stored inside
-objects by <code>with_vptr</code>.</p>
+objects by <code>inplace_vptr</code>.</p>
 </div>
 <div class="admonitionblock note">
 <table>
@@ -3131,7 +3131,7 @@ <h5 id="ref_boostopenmethodunique_hpp">&lt;boost/openmethod/unique_.hpp&gt;</h5>
 </div>
 </div>
 <div class="sect4">
-<h5 id="ref_boostopenmethodwith_vptr_hpp">&lt;boost/openmethod/with_vptr.hpp&gt;</h5>
+<h5 id="ref_boostopenmethodinplace_vptr_hpp">&lt;boost/openmethod/inplace_vptr.hpp&gt;</h5>
 <div class="paragraph">
 <p>Provides support for storing v-table pointers directly in objects, in the same
 manner as native virtual functions.</p>
@@ -4811,29 +4811,29 @@ <h4 id="virtual_ptr_description_4">Description</h4>
 </div>
 </div>
 <div class="sect2">
-<h3 id="virtual_ptr_with_vptr">with_vptr</h3>
+<h3 id="virtual_ptr_inplace_vptr">inplace_vptr</h3>
 <div class="sect3">
 <h4 id="virtual_ptr_synopsis_5">Synopsis</h4>
 <div class="paragraph">
-<p>Defined in &lt;boost/openmethod/with_vptr.hpp&gt;.</p>
+<p>Defined in &lt;boost/openmethod/inplace_vptr.hpp&gt;.</p>
 </div>
 <div class="listingblock">
 <div class="content">
 <pre class="rouge highlight"><code data-lang="c++">namespace boost::openmethod {
 
 template&lt;class Class, class Policy = BOOST_OPENMETHOD_DEFAULT_REGISTRY&gt;
-class with_vptr {
+class inplace_vptr {
   protected:
-    with_vptr();
-    ~with_vptr();
+    inplace_vptr();
+    ~inplace_vptr();
     friend auto boost_openmethod_vptr(const Class&amp; obj) -&gt; vptr_type;
 };
 
 template&lt;class Class, class Base, class... MoreBases&gt;
-class with_vptr {
+class inplace_vptr {
   protected:
-    with_vptr();
-    ~with_vptr();
+    inplace_vptr();
+    ~inplace_vptr();
     friend auto boost_openmethod_vptr(const Class&amp; obj) -&gt; vptr_type;
         // if sizeof(MoreBases...) &gt; 0
 };
@@ -4845,11 +4845,11 @@ <h4 id="virtual_ptr_synopsis_5">Synopsis</h4>
 <div class="sect3">
 <h4 id="virtual_ptr_description_5">Description</h4>
 <div class="paragraph">
-<p><code>with_vptr</code> is a CRTP class template that embeds and manages a vptr across a
+<p><code>inplace_vptr</code> is a CRTP class template that embeds and manages a vptr across a
 class hierarchy.</p>
 </div>
 <div class="paragraph">
-<p>If <code>Class</code> has no <code>Bases</code>, <code>with_vptr</code> adds a <code>boost_openmethod_vptr</code> private
+<p>If <code>Class</code> has no <code>Bases</code>, <code>inplace_vptr</code> adds a <code>boost_openmethod_vptr</code> private
 member to <code>Class</code>. In either case, it sets the vptr to the v-table of <code>Class</code>
 from <code>Policy</code>. It also creates a <code>boost_openmethod_vptr</code> friend function that
 takes a a <code>const Class&amp;</code> and returns the embedded vptr.</p>
@@ -4861,7 +4861,7 @@ <h4 id="virtual_ptr_description_5">Description</h4>
 ambiguities</p>
 </div>
 <div class="paragraph">
-<p>As part of its implementation, <code>with_vptr</code> may also declare one or two free
+<p>As part of its implementation, <code>inplace_vptr</code> may also declare one or two free
 functions (<code>boost_openmethod_policy</code> and <code>boost_openmethod_bases</code>) at certain
 levels of the hierarchy.</p>
 </div>
@@ -4872,7 +4872,7 @@ <h4 id="virtual_ptr_members_4">Members</h4>
 <h5 id="virtual_ptr_constructor_2">constructor</h5>
 <div class="listingblock">
 <div class="content">
-<pre class="rouge highlight"><code data-lang="c++">with_vptr();</code></pre>
+<pre class="rouge highlight"><code data-lang="c++">inplace_vptr();</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -4885,7 +4885,7 @@ <h5 id="virtual_ptr_constructor_2">constructor</h5>
 <h5 id="virtual_ptr_destructor_2">destructor</h5>
 <div class="listingblock">
 <div class="content">
-<pre class="rouge highlight"><code data-lang="c++">~with_vptr();</code></pre>
+<pre class="rouge highlight"><code data-lang="c++">~inplace_vptr();</code></pre>
 </div>
 </div>
 <div class="paragraph">
@@ -5612,7 +5612,7 @@ <h4 id="virtual_ptr_synopsis_15">Synopsis</h4>
 <div class="sect3">
 <h4 id="virtual_ptr_description_15">Description</h4>
 <div class="paragraph">
-<p><code>indirect_vptr</code> is a facet that makes <code>virtual_ptr</code>s and <code>with_vptr</code> use
+<p><code>indirect_vptr</code> is a facet that makes <code>virtual_ptr</code>s and <code>inplace_vptr</code> use
 pointers to pointers to v-tables, instead of straight pointers. As a
 consequence, they remain valid after a call to <code>initialize</code>.</p>
 </div>
@@ -6249,7 +6249,7 @@ <h4 id="virtual_ptr_description_25">Description</h4>
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2025-03-08 15:24:21 -0500
+Last updated 2025-06-22 13:38:14 -0400
 </div>
 </div>
 </body>

doc/with_vptr.adoc doc/inplace_vptr.adocdoc/with_vptr.adoc renamed to doc/inplace_vptr.adoc

@@ -1,26 +1,26 @@
 
-## with_vptr
+## inplace_vptr
 
 ### Synopsis
 
-Defined in <boost/openmethod/with_vptr.hpp>.
+Defined in <boost/openmethod/inplace_vptr.hpp>.
 
 ```c++
 namespace boost::openmethod {
 
 template<class Class, class Policy = BOOST_OPENMETHOD_DEFAULT_REGISTRY>
-class with_vptr {
+class inplace_vptr {
   protected:
-    with_vptr();
-    ~with_vptr();
+    inplace_vptr();
+    ~inplace_vptr();
     friend auto boost_openmethod_vptr(const Class& obj) -> vptr_type;
 };
 
 template<class Class, class Base, class... MoreBases>
-class with_vptr {
+class inplace_vptr {
   protected:
-    with_vptr();
-    ~with_vptr();
+    inplace_vptr();
+    ~inplace_vptr();
     friend auto boost_openmethod_vptr(const Class& obj) -> vptr_type;
         // if sizeof(MoreBases...) > 0
 };
@@ -30,10 +30,10 @@ class with_vptr {
 
 ### Description
 
-`with_vptr` is a CRTP class template that embeds and manages a vptr across a
+`inplace_vptr` is a CRTP class template that embeds and manages a vptr across a
 class hierarchy.
 
-If `Class` has no `Bases`, `with_vptr` adds a `boost_openmethod_vptr` private
+If `Class` has no `Bases`, `inplace_vptr` adds a `boost_openmethod_vptr` private
 member to `Class`. In either case, it sets the vptr to the v-table of `Class`
 from `Policy`. It also creates a `boost_openmethod_vptr` friend function that
 takes a a `const Class&` and returns the embedded vptr.
@@ -43,7 +43,7 @@ function is also created. It returns one of the embedded vptrs (it doesn't
 matter which one, as they all have the same value). This is to resolve
 ambiguities
 
-As part of its implementation, `with_vptr` may also declare one or two free
+As part of its implementation, `inplace_vptr` may also declare one or two free
 functions (`boost_openmethod_policy` and `boost_openmethod_bases`) at certain
 levels of the hierarchy.
 
@@ -52,7 +52,7 @@ levels of the hierarchy.
 #### constructor
 
 ```c++
-with_vptr();
+inplace_vptr();
 ```
 
 Sets the vptr to the v-table for Class, obtained from `Policy`. If `Policy`
@@ -63,7 +63,7 @@ preserving the validity of the pointer across calls to `initialize`.
 #### destructor
 
 ```c++
-~with_vptr();
+~inplace_vptr();
 ```
 
 For each `Base`, sets the vptr to the v-table for that base.

doc/overview.adoc

@@ -83,7 +83,7 @@ virtual parameters.
 Provides support for using `std::unique_ptr` in place of plain pointers in
 virtual parameters.
 
-#### <boost/openmethod/with_vptr.hpp>
+#### <boost/openmethod/inplace_vptr.hpp>
 
 Provides support for storing v-table pointers directly in objects, in the same
 manner as native virtual functions.

doc/reference.adoc

@@ -27,7 +27,7 @@ include::virtual_ptr.adoc[]
 include::virtual_traits.adoc[]
 include::use_classes.adoc[]
 include::virtual_.adoc[]
-include::with_vptr.adoc[]
+include::inplace_vptr.adoc[]
 include::abstract_policy.adoc[]
 include::domain.adoc[]
 include::basic_policy.adoc[]

doc/virtual_ptr_alt.adoc

@@ -53,12 +53,12 @@ NOTE: With this approach, classes need not be polymorphic. A virtual
 destructor might be needed for correct destruction of objects, but it is not
 required by the library.
 
-The `with_vptr` CRTP class automates the creation and management of embedded
+The `inplace_vptr` CRTP class automates the creation and management of embedded
 vptrs.
 
 [source,c++]
 ----
-include::{exampledir}/virtual_.cpp[tag=with_vptr,indent=0]
+include::{exampledir}/virtual_.cpp[tag=inplace_vptr,indent=0]
 
 int main() {
     boost::openmethod::initialize();
@@ -68,9 +68,9 @@ int main() {
 }
 ----
 
-If `with_vptr` is passed only the class being defined, it adds a vptr to it, and
+If `inplace_vptr` is passed only the class being defined, it adds a vptr to it, and
 defines a `boost_openmethod_vptr` friend function. If more classes are passed,
 they must be the direct bases of the class potentially involved in open-method
 calls. Its constructor and destructor set the vptr to point to the v-table for
-the class. `with_vptr` also takes care of registering the classes, so this time
+the class. `inplace_vptr` also takes care of registering the classes, so this time
 the call to `BOOST_OPENMETHOD_CLASSES` is not needed.

doc/vptr.adoc

@@ -55,7 +55,7 @@ struct indirect_vptr : facet {};
 
 ### Description
 
-`indirect_vptr` is a facet that makes `virtual_ptr`{empty}s and `with_vptr` use
+`indirect_vptr` is a facet that makes `virtual_ptr`{empty}s and `inplace_vptr` use
 pointers to pointers to v-tables, instead of straight pointers. As a
 consequence, they remain valid after a call to `initialize`.
 

example/virtual_.cpp

@@ -6,7 +6,7 @@
 #include <iostream>
 
 #include <boost/openmethod.hpp>
-#include <boost/openmethod/with_vptr.hpp>
+#include <boost/openmethod/inplace_vptr.hpp>
 #include <boost/openmethod/compiler.hpp>
 
 using boost::openmethod::virtual_;
@@ -68,26 +68,26 @@ BOOST_OPENMETHOD_CLASSES(Animal, Cat);
 // end::virtual_intrusive[]
 } // namespace virtual_intrusive
 
-namespace with_vptr {
+namespace inplace_vptr {
 
-// tag::with_vptr[]
+// tag::inplace_vptr[]
 
-#include <boost/openmethod/with_vptr.hpp>
+#include <boost/openmethod/inplace_vptr.hpp>
 
-class Animal : public boost::openmethod::with_vptr<Animal> {
+class Animal : public boost::openmethod::inplace_vptr<Animal> {
 };
 
-class Cat : public Animal, public boost::openmethod::with_vptr<Cat, Animal> {
+class Cat : public Animal, public boost::openmethod::inplace_vptr<Cat, Animal> {
 };
 
 BOOST_OPENMETHOD(poke, (std::ostream&, virtual_<Animal&>), void);
 
 BOOST_OPENMETHOD_OVERRIDE(poke, (std::ostream & os, Cat& /*cat*/), void) {
     os << "hiss\n";
 }
-// end::with_vptr[]
+// end::inplace_vptr[]
 
-} // namespace with_vptr
+} // namespace inplace_vptr
 
 auto main() -> int {
     boost::openmethod::initialize();
@@ -105,7 +105,7 @@ auto main() -> int {
     }
 
     {
-        using namespace with_vptr;
+        using namespace inplace_vptr;
         Cat cat;
         poke(std::cout, cat); // hiss
     }

include/boost/openmethod/core.hpp

@@ -981,8 +981,8 @@ template<typename T, class Registry>
 struct valid_method_parameter<virtual_<T>, Registry>
     : std::bool_constant<
           has_vptr_fn<virtual_type<T, Registry>, Registry> ||
-          Registry::rtti::template is_polymorphic<
-              virtual_type<T, Registry>>> {};
+          Registry::rtti::template is_polymorphic<virtual_type<T, Registry>>> {
+};
 
 } // namespace detail