| <html> |
| <head> |
| <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> |
| <title>Chapter 1. Boost.Functional/Factory 1.0</title> |
| <link rel="stylesheet" href="boostbook.css" type="text/css"> |
| <meta name="generator" content="DocBook XSL Stylesheets V1.68.1"> |
| <link rel="start" href="index.html" title="Chapter 1. Boost.Functional/Factory 1.0"> |
| </head> |
| <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"> |
| <table cellpadding="2" width="100%"><tr> |
| <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td> |
| <td align="center"><a href="../../../../../index.html">Home</a></td> |
| <td align="center"><a href="../../../../libraries.htm">Libraries</a></td> |
| <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td> |
| <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td> |
| <td align="center"><a href="../../../../../more/index.htm">More</a></td> |
| </tr></table> |
| <hr> |
| <div class="spirit-nav"></div> |
| <div class="chapter" lang="en"> |
| <div class="titlepage"><div> |
| <div><h2 class="title"> |
| <a name="boost_functional_factory"></a>Chapter 1. Boost.Functional/Factory 1.0</h2></div> |
| <div><div class="author"><h3 class="author"> |
| <span class="firstname">Tobias</span> <span class="surname">Schwinger</span> |
| </h3></div></div> |
| <div><p class="copyright">Copyright © 2007, 2008 Tobias Schwinger</p></div> |
| <div><div class="legalnotice"> |
| <a name="id934161"></a><p> |
| Distributed under the Boost Software License, Version 1.0. (See accompanying |
| file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>) |
| </p> |
| </div></div> |
| </div></div> |
| <div class="toc"> |
| <p><b>Table of Contents</b></p> |
| <dl> |
| <dt><span class="section"><a href="index.html#boost_functional_factory.brief_description">Brief Description</a></span></dt> |
| <dt><span class="section"><a href="index.html#boost_functional_factory.background">Background</a></span></dt> |
| <dt><span class="section"><a href="index.html#boost_functional_factory.reference"> Reference</a></span></dt> |
| <dt><span class="section"><a href="index.html#boost_functional_factory.acknowledgements">Acknowledgements</a></span></dt> |
| <dt><span class="section"><a href="index.html#boost_functional_factory.references">References</a></span></dt> |
| </dl> |
| </div> |
| <div class="section" lang="en"> |
| <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
| <a name="boost_functional_factory.brief_description"></a><a href="index.html#boost_functional_factory.brief_description" title="Brief Description">Brief Description</a></h2></div></div></div> |
| <p> |
| The template <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code> lets you encapsulate a <code class="computeroutput"><span class="keyword">new</span></code> expression as a function object, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code> |
| encapsulates a constructor invocation without <code class="computeroutput"><span class="keyword">new</span></code>. |
| </p> |
| <pre class="programlisting"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code><span class="special"><</span><span class="identifier">T</span><span class="special">*>()(</span><span class="identifier">arg1</span><span class="special">,</span><span class="identifier">arg2</span><span class="special">,</span><span class="identifier">arg3</span><span class="special">)</span> |
| <span class="comment">// same as new T(arg1,arg2,arg3) |
| </span> |
| <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code><span class="special"><</span><span class="identifier">T</span><span class="special">>()(</span><span class="identifier">arg1</span><span class="special">,</span><span class="identifier">arg2</span><span class="special">,</span><span class="identifier">arg3</span><span class="special">)</span> |
| <span class="comment">// same as T(arg1,arg2,arg3) |
| </span></pre> |
| <p> |
| For technical reasons the arguments to the function objects have to be LValues. |
| A factory that also accepts RValues can be composed using the <a href="http://www.boost.org/libs/functional/forward/doc/index.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward_adapter</span></code></a> |
| or <a href="http://www.boost.org/libs/bind/bind.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span></code></a>. |
| </p> |
| </div> |
| <div class="section" lang="en"> |
| <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
| <a name="boost_functional_factory.background"></a><a href="index.html#boost_functional_factory.background" title="Background">Background</a></h2></div></div></div> |
| <p> |
| In traditional Object Oriented Programming a Factory is an object implementing |
| an interface of one or more methods that construct objects conforming to known |
| interfaces. |
| </p> |
| <pre class="programlisting"><span class="comment">// assuming a_concrete_class and another_concrete_class are derived |
| </span><span class="comment">// from an_abstract_class |
| </span> |
| <span class="keyword">class</span> <span class="identifier">a_factory</span> |
| <span class="special">{</span> |
| <span class="keyword">public</span><span class="special">:</span> |
| <span class="keyword">virtual</span> <span class="identifier">an_abstract_class</span><span class="special">*</span> <span class="identifier">create</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> |
| <span class="keyword">virtual</span> <span class="special">~</span><span class="identifier">a_factory</span><span class="special">()</span> <span class="special">{</span> <span class="special">}</span> |
| <span class="special">};</span> |
| |
| <span class="keyword">class</span> <span class="identifier">a_concrete_factory</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">a_factory</span> |
| <span class="special">{</span> |
| <span class="keyword">public</span><span class="special">:</span> |
| <span class="keyword">virtual</span> <span class="identifier">an_abstract_class</span><span class="special">*</span> <span class="identifier">create</span><span class="special">()</span> <span class="keyword">const</span> |
| <span class="special">{</span> |
| <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">a_concrete_class</span><span class="special">();</span> |
| <span class="special">}</span> |
| <span class="special">};</span> |
| |
| <span class="keyword">class</span> <span class="identifier">another_concrete_factory</span> <span class="special">:</span> <span class="keyword">public</span> <span class="identifier">a_factory</span> |
| <span class="special">{</span> |
| <span class="keyword">public</span><span class="special">:</span> |
| <span class="keyword">virtual</span> <span class="identifier">an_abstract_class</span><span class="special">*</span> <span class="identifier">create</span><span class="special">()</span> <span class="keyword">const</span> |
| <span class="special">{</span> |
| <span class="keyword">return</span> <span class="keyword">new</span> <span class="identifier">another_concrete_class</span><span class="special">();</span> |
| <span class="special">}</span> |
| <span class="special">};</span> |
| |
| <span class="comment">// [...] |
| </span> |
| <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> |
| <span class="special">{</span> |
| <a href="http://www.boost.org/libs/ptr_container/doc/ptr_map.html" target="_top"><code class="computeroutput"><span class="identifier">__boost__ptr_map__</span></code></a><span class="special"><</span><a href="http://www.sgi.com/tech/stl/string.html" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code></a><span class="special">,</span><span class="identifier">a_factory</span><span class="special">></span> <span class="identifier">factories</span><span class="special">;</span> |
| |
| <span class="comment">// [...] |
| </span> |
| <span class="identifier">factories</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="string">"a_name"</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">auto_ptr</span><span class="special"><</span><span class="identifier">a_factory</span><span class="special">>(</span> |
| <span class="keyword">new</span> <span class="identifier">a_concrete_factory</span><span class="special">));</span> |
| <span class="identifier">factories</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="string">"another_name"</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">auto_ptr</span><span class="special"><</span><span class="identifier">a_factory</span><span class="special">>(</span> |
| <span class="keyword">new</span> <span class="identifier">another_concrete_factory</span><span class="special">));</span> |
| |
| <span class="comment">// [...] |
| </span> |
| <span class="identifier">std</span><span class="special">::</span><span class="identifier">auto_ptr</span><span class="special"><</span><span class="identifier">an_abstract_factory</span><span class="special">></span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">factories</span><span class="special">[</span><span class="identifier">some_name</span><span class="special">]-></span><span class="identifier">create</span><span class="special">();</span> |
| |
| <span class="comment">// [...] |
| </span><span class="special">}</span> |
| </pre> |
| <p> |
| This approach has several drawbacks. The most obvious one is that there is |
| lots of boilerplate code. In other words there is too much code to express |
| a rather simple intention. We could use templates to get rid of some of it |
| but the approach remains inflexible: |
| </p> |
| <pre class="programlisting"><span class="identifier">o</span> <span class="identifier">We</span> <span class="identifier">may</span> <span class="identifier">want</span> <span class="identifier">a</span> <span class="identifier">factory</span> <span class="identifier">that</span> <span class="identifier">takes</span> <span class="identifier">some</span> <span class="identifier">arguments</span> <span class="identifier">that</span> <span class="identifier">are</span> <span class="identifier">forwarded</span> <span class="identifier">to</span> |
| <span class="identifier">the</span> <span class="identifier">constructor</span><span class="special">,</span> |
| <span class="identifier">o</span> <span class="identifier">we</span> <span class="identifier">will</span> <span class="identifier">probably</span> <span class="identifier">want</span> <span class="identifier">to</span> <span class="identifier">use</span> <span class="identifier">smart</span> <span class="identifier">pointers</span><span class="special">,</span> |
| <span class="identifier">o</span> <span class="identifier">we</span> <span class="identifier">may</span> <span class="identifier">want</span> <span class="identifier">several</span> <span class="identifier">member</span> <span class="identifier">functions</span> <span class="identifier">to</span> <span class="identifier">create</span> <span class="identifier">different</span> <span class="identifier">kinds</span> <span class="identifier">of</span> |
| <span class="identifier">objects</span><span class="special">,</span> |
| <span class="identifier">o</span> <span class="identifier">we</span> <span class="identifier">might</span> <span class="keyword">not</span> <span class="identifier">necessarily</span> <span class="identifier">need</span> <span class="identifier">a</span> <span class="identifier">polymorphic</span> <span class="identifier">base</span> <span class="keyword">class</span> <span class="keyword">for</span> <span class="identifier">the</span> <span class="identifier">objects</span><span class="special">,</span> |
| <span class="identifier">o</span> <span class="identifier">as</span> <span class="identifier">we</span> <span class="identifier">will</span> <span class="identifier">see</span><span class="special">,</span> <span class="identifier">we</span> <span class="keyword">do</span> <span class="keyword">not</span> <span class="identifier">need</span> <span class="identifier">a</span> <span class="identifier">factory</span> <span class="identifier">base</span> <span class="keyword">class</span> <span class="identifier">at</span> <span class="identifier">all</span><span class="special">,</span> |
| <span class="identifier">o</span> <span class="identifier">we</span> <span class="identifier">might</span> <span class="identifier">want</span> <span class="identifier">to</span> <span class="identifier">just</span> <span class="identifier">call</span> <span class="identifier">the</span> <span class="identifier">constructor</span> <span class="special">-</span> <span class="identifier">without</span> #<span class="keyword">new</span># <span class="identifier">to</span> <span class="identifier">create</span> |
| <span class="identifier">an</span> <span class="identifier">object</span> <span class="identifier">on</span> <span class="identifier">the</span> <span class="identifier">stack</span><span class="special">,</span> <span class="keyword">and</span> |
| <span class="identifier">o</span> <span class="identifier">finally</span> <span class="identifier">we</span> <span class="identifier">might</span> <span class="identifier">want</span> <span class="identifier">to</span> <span class="identifier">use</span> <span class="identifier">customized</span> <span class="identifier">memory</span> <span class="identifier">management</span><span class="special">.</span> |
| </pre> |
| <p> |
| Experience has shown that using function objects and generic Boost components |
| for their composition, Design Patterns that describe callback mechasisms (typically |
| requiring a high percentage of boilerplate code with pure Object Oriented methodology) |
| become implementable with just few code lines and without extra classes. |
| </p> |
| <p> |
| Factories are callback mechanisms for constructors, so we provide two class |
| templates, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code> and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code>, |
| that encasulate object construction via direct application of the constructor |
| and the <code class="computeroutput"><span class="keyword">new</span></code> operator, respectively. |
| </p> |
| <p> |
| We let the function objects forward their arguments to the construction expressions |
| they encapsulate. Overthis <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code> |
| optionally allows the use of smart pointers and <a href="http://www.sgi.com/tech/stl/concepts/allocator.html" target="_top">Allocators</a>. |
| </p> |
| <p> |
| Compile-time polymorphism can be used where appropriate, |
| </p> |
| <pre class="programlisting"><span class="keyword">template</span><span class="special"><</span> <span class="keyword">class</span> <span class="identifier">T</span> <span class="special">></span> |
| <span class="keyword">void</span> <span class="identifier">do_something</span><span class="special">()</span> |
| <span class="special">{</span> |
| <span class="comment">// [...] |
| </span> <span class="identifier">T</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">T</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">);</span> |
| |
| <span class="comment">// for conceptually similar objects x we neither need virtual |
| </span> <span class="comment">// functions nor a common base class in this context. |
| </span> <span class="comment">// [...] |
| </span><span class="special">}</span> |
| </pre> |
| <p> |
| Now, to allow inhomogenous signaturs for the constructors of the types passed |
| in for <code class="computeroutput"><span class="identifier">T</span></code> we can use <code class="computeroutput"><span class="identifier">value_factory</span></code> and <a href="http://www.boost.org/libs/bind/bind.html" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span></code></a> |
| to normalize between them. |
| </p> |
| <pre class="programlisting"><span class="keyword">template</span><span class="special"><</span> <span class="keyword">class</span> <span class="identifier">ValueFactory</span> <span class="special">></span> |
| <span class="keyword">void</span> <span class="identifier">do_something</span><span class="special">(</span><span class="identifier">ValueFactory</span> <span class="identifier">make_obj</span> <span class="special">=</span> <span class="identifier">ValueFactory</span><span class="special">())</span> |
| <span class="special">{</span> |
| <span class="comment">// [...] |
| </span> <span class="keyword">typename</span> <span class="identifier">ValueFactory</span><span class="special">::</span><span class="identifier">result_type</span> <span class="identifier">x</span> <span class="special">=</span> <span class="identifier">make_obj</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">);</span> |
| |
| <span class="comment">// for conceptually similar objects x we neither need virtual |
| </span> <span class="comment">// functions nor a common base class in this context. |
| </span> <span class="comment">// [...] |
| </span><span class="special">}</span> |
| |
| <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> |
| <span class="special">{</span> |
| <span class="comment">// [...] |
| </span> |
| <span class="identifier">do_something</span><span class="special">(</span><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code><span class="special"><</span><span class="identifier">X</span><span class="special">>());</span> |
| <span class="identifier">do_something</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">bind</span><span class="special">(</span><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">value_factory</span></code><span class="special"><</span><span class="identifier">Y</span><span class="special">>(),</span><span class="identifier">_1</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="identifier">_2</span><span class="special">));</span> |
| <span class="comment">// construct X(a,b) and Y(a,5,b), respectively. |
| </span> |
| <span class="comment">// [...] |
| </span><span class="special">}</span> |
| </pre> |
| <p> |
| Maybe we want our objects to outlive the function's scope, in this case we |
| have to use dynamic allocation; |
| </p> |
| <pre class="programlisting"><span class="keyword">template</span><span class="special"><</span> <span class="keyword">class</span> <span class="identifier">Factory</span> <span class="special">></span> |
| <span class="identifier">whatever</span> <span class="identifier">do_something</span><span class="special">(</span><span class="identifier">Factory</span> <span class="identifier">new_obj</span> <span class="special">=</span> <span class="identifier">Factory</span><span class="special">())</span> |
| <span class="special">{</span> |
| <span class="keyword">typename</span> <span class="identifier">Factory</span><span class="special">::</span><span class="identifier">result_type</span> <span class="identifier">ptr</span> <span class="special">=</span> <span class="identifier">new_obj</span><span class="special">(</span><span class="identifier">a</span><span class="special">,</span><span class="identifier">b</span><span class="special">);</span> |
| |
| <span class="comment">// again, no common base class or virtual functions needed, |
| </span> <span class="comment">// we could enforce a polymorphic base by writing e.g. |
| </span> <span class="comment">// boost::shared_ptr<base> |
| </span> <span class="comment">// instead of |
| </span> <span class="comment">// typename Factory::result_type |
| </span> <span class="comment">// above. |
| </span> <span class="comment">// Note that we are also free to have the type erasure happen |
| </span> <span class="comment">// somewhere else (e.g. in the constructor of this function's |
| </span> <span class="comment">// result type). |
| </span> |
| <span class="comment">// [...] |
| </span><span class="special">}</span> |
| |
| <span class="comment">// [... call do_something like above but with __factory__ instead |
| </span><span class="comment">// of __value_factory__] |
| </span></pre> |
| <p> |
| Although we might have created polymorphic objects in the previous example, |
| we have used compile time polymorphism for the factory. If we want to erase |
| the type of the factory and thus allow polymorphism at run time, we can use |
| <a href="http://www.boost.org/doc/html/function.html" target="_top">Boost.Function</a> |
| to do so. The first example can be rewritten as follows. |
| </p> |
| <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">function</span><span class="special"><</span> <span class="identifier">an_abstract_class</span><span class="special">*()</span> <span class="special">></span> <span class="identifier">a_factory</span><span class="special">;</span> |
| |
| <span class="comment">// [...] |
| </span> |
| <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> |
| <span class="special">{</span> |
| <a href="http://www.sgi.com/tech/stl/map.html" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span></code></a><span class="special"><</span><a href="http://www.sgi.com/tech/stl/string.html" target="_top"><code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code></a><span class="special">,</span><span class="identifier">a_factory</span><span class="special">></span> <span class="identifier">factories</span><span class="special">;</span> |
| |
| <span class="comment">// [...] |
| </span> |
| <span class="identifier">factories</span><span class="special">[</span><span class="string">"a_name"</span><span class="special">]</span> <span class="special">=</span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code><span class="special"><</span><span class="identifier">a_concrete_class</span><span class="special">*>();</span> |
| <span class="identifier">factories</span><span class="special">[</span><span class="string">"another_name"</span><span class="special">]</span> <span class="special">=</span> |
| <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">factory</span></code><span class="special"><</span><span class="identifier">another_concrete_class</span><span class="special">*>();</span> |
| |
| <span class="comment">// [...] |
| </span><span class="special">}</span> |
| </pre> |
| <p> |
| Of course we can just as easy create factories that take arguments and/or return |
| <a href="http://www.boost.org/libs/smart_ptr/index.html" target="_top">Smart Pointers</a>. |
| </p> |
| </div> |
| <div class="section" lang="en"> |
| <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
| <a name="boost_functional_factory.reference"></a><a href="index.html#boost_functional_factory.reference" title=" Reference"> Reference</a></h2></div></div></div> |
| <div class="toc"><dl> |
| <dt><span class="section"><a href="index.html#boost_functional_factory.reference.value_factory">value_factory</a></span></dt> |
| <dt><span class="section"><a href="index.html#boost_functional_factory.reference.factory">factory</a></span></dt> |
| </dl></div> |
| <div class="section" lang="en"> |
| <div class="titlepage"><div><div><h3 class="title"> |
| <a name="boost_functional_factory.reference.value_factory"></a><a href="index.html#boost_functional_factory.reference.value_factory" title="value_factory">value_factory</a></h3></div></div></div> |
| <a name="boost_functional_factory.reference.value_factory.description"></a><h4> |
| <a name="id936876"></a> |
| <a href="index.html#boost_functional_factory.reference.value_factory.description">Description</a> |
| </h4> |
| <p> |
| Function object template that invokes the constructor of the type <code class="computeroutput"><span class="identifier">T</span></code>. |
| </p> |
| <a name="boost_functional_factory.reference.value_factory.header"></a><h4> |
| <a name="id936914"></a> |
| <a href="index.html#boost_functional_factory.reference.value_factory.header">Header</a> |
| </h4> |
| <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">functional</span><span class="special">/</span><span class="identifier">value_factory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> |
| </pre> |
| <a name="boost_functional_factory.reference.value_factory.synopsis"></a><h4> |
| <a name="id936989"></a> |
| <a href="index.html#boost_functional_factory.reference.value_factory.synopsis">Synopsis</a> |
| </h4> |
| <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> |
| <span class="special">{</span> |
| <span class="keyword">template</span><span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">T</span> <span class="special">></span> |
| <span class="keyword">class</span> <span class="identifier">value_factory</span><span class="special">;</span> |
| <span class="special">}</span> |
| </pre> |
| <div class="variablelist"> |
| <p class="title"><b>Notation</b></p> |
| <dl> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">T</span></code></span></dt> |
| <dd><p> |
| an arbitrary type with at least one public constructor |
| </p></dd> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span></code></span></dt> |
| <dd><p> |
| argument LValues to a constructor of <code class="computeroutput"><span class="identifier">T</span></code> |
| </p></dd> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">F</span></code></span></dt> |
| <dd><p> |
| the type <code class="computeroutput"><span class="identifier">value_factory</span><span class="special"><</span><span class="identifier">F</span><span class="special">></span></code> |
| </p></dd> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">f</span></code></span></dt> |
| <dd><p> |
| an instance object of <code class="computeroutput"><span class="identifier">F</span></code> |
| </p></dd> |
| </dl> |
| </div> |
| <a name="boost_functional_factory.reference.value_factory.expression_semantics"></a><h4> |
| <a name="id937226"></a> |
| <a href="index.html#boost_functional_factory.reference.value_factory.expression_semantics">Expression |
| Semantics</a> |
| </h4> |
| <div class="informaltable"><table class="table"> |
| <colgroup> |
| <col> |
| <col> |
| </colgroup> |
| <thead><tr> |
| <th> |
| <p> |
| Expression |
| </p> |
| </th> |
| <th> |
| <p> |
| Semantics |
| </p> |
| </th> |
| </tr></thead> |
| <tbody> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">F</span><span class="special">()</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>. |
| </p> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">F</span><span class="special">(</span><span class="identifier">f</span><span class="special">)</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>. |
| </p> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span><span class="special">)</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| returns <code class="computeroutput"><span class="identifier">T</span><span class="special">(</span><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span><span class="special">)</span></code>. |
| </p> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| is the type <code class="computeroutput"><span class="identifier">T</span></code>. |
| </p> |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <a name="boost_functional_factory.reference.value_factory.limits"></a><h4> |
| <a name="id937498"></a> |
| <a href="index.html#boost_functional_factory.reference.value_factory.limits">Limits</a> |
| </h4> |
| <p> |
| The macro BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY can be defined to set |
| the maximum arity. It defaults to 10. |
| </p> |
| </div> |
| <div class="section" lang="en"> |
| <div class="titlepage"><div><div><h3 class="title"> |
| <a name="boost_functional_factory.reference.factory"></a><a href="index.html#boost_functional_factory.reference.factory" title="factory">factory</a></h3></div></div></div> |
| <a name="boost_functional_factory.reference.factory.description"></a><h4> |
| <a name="id937545"></a> |
| <a href="index.html#boost_functional_factory.reference.factory.description">Description</a> |
| </h4> |
| <p> |
| Function object template that dynamically constructs a pointee object for |
| the type of pointer given as template argument. Smart pointers may be used |
| for the template argument, given that <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">pointee</span><span class="special"><</span><span class="identifier">Pointer</span><span class="special">>::</span><span class="identifier">type</span></code> |
| yields the pointee type. |
| </p> |
| <p> |
| If an <span class="underline">_allocator</span>_ is given, it is used |
| for memory allocation and the placement form of the <code class="computeroutput"><span class="keyword">new</span></code> |
| operator is used to construct the object. A function object that calls the |
| destructor and deallocates the memory with a copy of the Allocator is used |
| for the second constructor argument of <code class="computeroutput"><span class="identifier">Pointer</span></code> |
| (thus it must be a __smart<span class="underline">pointer</span>_ |
| that provides a suitable constructor, such as <a href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span></code></a>). |
| </p> |
| <p> |
| If a third template argument is <code class="computeroutput"><span class="identifier">factory_passes_alloc_to_smart_pointer</span></code>, |
| the allocator itself is used for the third constructor argument of <code class="computeroutput"><span class="identifier">Pointer</span></code> (<a href="http://www.boost.org/libs/smart_ptr/shared_ptr.htm" target="_top"><code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span></code></a> then uses the allocator |
| to manage the memory of its seperately allocated reference counter). |
| </p> |
| <a name="boost_functional_factory.reference.factory.header"></a><h4> |
| <a name="id937729"></a> |
| <a href="index.html#boost_functional_factory.reference.factory.header">Header</a> |
| </h4> |
| <pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">functional</span><span class="special">/</span><span class="identifier">factory</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span> |
| </pre> |
| <a name="boost_functional_factory.reference.factory.synopsis"></a><h4> |
| <a name="id937804"></a> |
| <a href="index.html#boost_functional_factory.reference.factory.synopsis">Synopsis</a> |
| </h4> |
| <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> |
| <span class="special">{</span> |
| <span class="keyword">enum</span> <span class="identifier">factory_alloc_propagation</span> |
| <span class="special">{</span> |
| <span class="identifier">factory_alloc_for_pointee_and_deleter</span><span class="special">,</span> |
| <span class="identifier">factory_passes_alloc_to_smart_pointer</span> |
| <span class="special">};</span> |
| |
| <span class="keyword">template</span><span class="special"><</span> <span class="keyword">typename</span> <span class="identifier">Pointer</span><span class="special">,</span> |
| <span class="keyword">class</span> <span class="identifier">Allocator</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">none_t</span><span class="special">,</span> |
| <span class="identifier">factory_alloc_propagation</span> <span class="identifier">AllocProp</span> <span class="special">=</span> |
| <span class="identifier">factory_alloc_for_pointee_and_deleter</span> <span class="special">></span> |
| <span class="keyword">class</span> <span class="identifier">factory</span><span class="special">;</span> |
| <span class="special">}</span> |
| </pre> |
| <div class="variablelist"> |
| <p class="title"><b>Notation</b></p> |
| <dl> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">T</span></code></span></dt> |
| <dd><p> |
| an arbitrary type with at least one public constructor |
| </p></dd> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">P</span></code></span></dt> |
| <dd><p> |
| pointer or smart pointer to <code class="computeroutput"><span class="identifier">T</span></code> |
| </p></dd> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span></code></span></dt> |
| <dd><p> |
| argument LValues to a constructor of <code class="computeroutput"><span class="identifier">T</span></code> |
| </p></dd> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">F</span></code></span></dt> |
| <dd><p> |
| the type <code class="computeroutput"><span class="identifier">factory</span><span class="special"><</span><span class="identifier">P</span><span class="special">></span></code> |
| </p></dd> |
| <dt><span class="term"><code class="computeroutput"><span class="identifier">f</span></code></span></dt> |
| <dd><p> |
| an instance object of <code class="computeroutput"><span class="identifier">F</span></code> |
| </p></dd> |
| </dl> |
| </div> |
| <a name="boost_functional_factory.reference.factory.expression_semantics"></a><h4> |
| <a name="id938169"></a> |
| <a href="index.html#boost_functional_factory.reference.factory.expression_semantics">Expression |
| Semantics</a> |
| </h4> |
| <div class="informaltable"><table class="table"> |
| <colgroup> |
| <col> |
| <col> |
| </colgroup> |
| <thead><tr> |
| <th> |
| <p> |
| Expression |
| </p> |
| </th> |
| <th> |
| <p> |
| Semantics |
| </p> |
| </th> |
| </tr></thead> |
| <tbody> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">F</span><span class="special">()</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>. |
| </p> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">F</span><span class="special">(</span><span class="identifier">f</span><span class="special">)</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| creates an object of type <code class="computeroutput"><span class="identifier">F</span></code>. |
| </p> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">f</span><span class="special">(</span><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span><span class="special">)</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| dynamically creates an object of type <code class="computeroutput"><span class="identifier">T</span></code> |
| using <code class="computeroutput"><span class="identifier">a0</span></code>...<code class="computeroutput"><span class="identifier">aN</span></code> as arguments for the constructor |
| invocation. |
| </p> |
| </td> |
| </tr> |
| <tr> |
| <td> |
| <p> |
| <code class="computeroutput"><span class="identifier">F</span><span class="special">::</span><span class="identifier">result_type</span></code> |
| </p> |
| </td> |
| <td> |
| <p> |
| is the type <code class="computeroutput"><span class="identifier">P</span></code> with |
| top-level cv-qualifiers removed. |
| </p> |
| </td> |
| </tr> |
| </tbody> |
| </table></div> |
| <a name="boost_functional_factory.reference.factory.limits"></a><h4> |
| <a name="id938440"></a> |
| <a href="index.html#boost_functional_factory.reference.factory.limits">Limits</a> |
| </h4> |
| <p> |
| The macro BOOST_FUNCTIONAL_FACTORY_MAX_ARITY can be defined to set the maximum |
| arity. It defaults to 10. |
| </p> |
| </div> |
| </div> |
| <div class="section" lang="en"> |
| <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
| <a name="boost_functional_factory.acknowledgements"></a><a href="index.html#boost_functional_factory.acknowledgements" title="Acknowledgements">Acknowledgements</a></h2></div></div></div> |
| <p> |
| Eric Niebler requested a function to invoke a type's constructor (with the |
| arguments supplied as a Tuple) as a Fusion feature. These Factory utilities |
| are a factored-out generalization of this idea. |
| </p> |
| <p> |
| Dave Abrahams suggested Smart Pointer support for exception safety, providing |
| useful hints for the implementation. |
| </p> |
| <p> |
| Joel de Guzman's documentation style was copied from Fusion. |
| </p> |
| <p> |
| Further, I want to thank Peter Dimov for sharing his insights on language details |
| and their evolution. |
| </p> |
| </div> |
| <div class="section" lang="en"> |
| <div class="titlepage"><div><div><h2 class="title" style="clear: both"> |
| <a name="boost_functional_factory.references"></a><a href="index.html#boost_functional_factory.references" title="References">References</a></h2></div></div></div> |
| <div class="orderedlist"><ol type="1"> |
| <li> |
| <a href="http://en.wikipedia.org/wiki/Design_Patterns" target="_top">Design Patterns</a>, |
| Gamma et al. - Addison Wesley Publishing, 1995 |
| </li> |
| <li> |
| <a href="http://www.sgi.com/tech/stl/" target="_top">Standard Template Library Programmer's |
| Guide</a>, Hewlett-Packard Company, 1994 |
| </li> |
| <li> |
| <a href="http://www.boost.org/libs/bind/bind.html" target="_top">Boost.Bind</a>, |
| Peter Dimov, 2001-2005 |
| </li> |
| <li> |
| <a href="http://www.boost.org/doc/html/function.html" target="_top">Boost.Function</a>, |
| Douglas Gregor, 2001-2004 |
| </li> |
| </ol></div> |
| </div> |
| </div> |
| <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> |
| <td align="left"><p><small>Last revised: November 01, 2008 at 21:44:52 GMT</small></p></td> |
| <td align="right"><div class="copyright-footer"></div></td> |
| </tr></table> |
| <hr> |
| <div class="spirit-nav"></div> |
| </body> |
| </html> |
