In common.h, define func_lib for function objects. In configure.ac, define HAVE_STD_FUNCTION and HAVE_BOOST_FUNCTION. Include function headers in ndnboost.
diff --git a/libs/functional/factory/doc/Jamfile b/libs/functional/factory/doc/Jamfile
new file mode 100644
index 0000000..1653336
--- /dev/null
+++ b/libs/functional/factory/doc/Jamfile
@@ -0,0 +1,20 @@
+
+# (C) Copyright Tobias Schwinger
+#
+# Use modification and distribution are subject to the boost Software License,
+# Version 1.0. (See http:/\/www.boost.org/LICENSE_1_0.txt).
+
+using quickbook ;
+
+xml factory : factory.qbk ;
+boostbook standalone : factory
+ :
+ <xsl:param>boost.root=../../../../..
+ <xsl:param>boost.libraries=../../../../libraries.htm
+ <xsl:param>chunk.section.depth=0
+ <xsl:param>chunk.first.sections=0
+ <xsl:param>generate.section.toc.level=2
+ <xsl:param>toc.max.depth=1
+ ;
+
+
diff --git a/libs/functional/factory/doc/factory.qbk b/libs/functional/factory/doc/factory.qbk
new file mode 100644
index 0000000..7aa3faf
--- /dev/null
+++ b/libs/functional/factory/doc/factory.qbk
@@ -0,0 +1,386 @@
+[library Boost.Functional/Factory
+ [quickbook 1.3]
+ [version 1.0]
+ [authors [Schwinger, Tobias]]
+ [copyright 2007 2008 Tobias Schwinger]
+ [license
+ Distributed under the Boost Software License, Version 1.0.
+ (See accompanying file LICENSE_1_0.txt or copy at
+ [@http://www.boost.org/LICENSE_1_0.txt])
+ ]
+ [purpose Function object templates for object creation.]
+ [category higher-order]
+ [category generic]
+ [last-revision $Date: 2008/11/01 21:44:52 $]
+]
+
+[def __boost_bind__ [@http://www.boost.org/libs/bind/bind.html Boost.Bind]]
+[def __boost__bind__ [@http://www.boost.org/libs/bind/bind.html `boost::bind`]]
+
+[def __boost__forward_adapter__ [@http://www.boost.org/libs/functional/forward/doc/index.html `boost::forward_adapter`]]
+[def __fusion_functional_adapters__ [@http://www.boost.org/libs/fusion/doc/html/functional.html Fusion Functional Adapters]]
+
+[def __boost_function__ [@http://www.boost.org/doc/html/function.html Boost.Function]]
+[def __boost__function__ [@http://www.boost.org/doc/html/function.html `boost::function`]]
+
+[def __smart_pointer__ [@http://www.boost.org/libs/smart_ptr/index.html Smart Pointer]]
+[def __smart_pointers__ [@http://www.boost.org/libs/smart_ptr/index.html Smart Pointers]]
+[def __boost__shared_ptr__ [@http://www.boost.org/libs/smart_ptr/shared_ptr.htm `boost::shared_ptr`]]
+
+[def __std__map__ [@http://www.sgi.com/tech/stl/map.html `std::map`]]
+[def __std__string__ [@http://www.sgi.com/tech/stl/string.html `std::string`]]
+[def __allocator__ [@http://www.sgi.com/tech/stl/concepts/allocator.html Allocator]]
+[def __std_allocator__ [@http://www.sgi.com/tech/stl/concepts/allocator.html Allocator]]
+[def __std_allocators__ [@http://www.sgi.com/tech/stl/concepts/allocator.html Allocators]]
+
+[def __boost__ptr_map__ [@http://www.boost.org/libs/ptr_container/doc/ptr_map.html `boost::ptr_map`]]
+
+[def __boost__factory__ `boost::factory`]
+[def __boost__value_factory__ `boost::value_factory`]
+
+[def __factory__ `factory`]
+[def __value_factory__ `value_factory`]
+
+
+[section Brief Description]
+
+The template __boost__factory__ lets you encapsulate a `new` expression
+as a function object, __boost__value_factory__ encapsulates a constructor
+invocation without `new`.
+
+ __boost__factory__<T*>()(arg1,arg2,arg3)
+ // same as new T(arg1,arg2,arg3)
+
+ __boost__value_factory__<T>()(arg1,arg2,arg3)
+ // same as T(arg1,arg2,arg3)
+
+For technical reasons the arguments to the function objects have to be
+LValues. A factory that also accepts RValues can be composed using the
+__boost__forward_adapter__ or __boost__bind__.
+
+[endsect]
+
+[section Background]
+
+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.
+
+ // assuming a_concrete_class and another_concrete_class are derived
+ // from an_abstract_class
+
+ class a_factory
+ {
+ public:
+ virtual an_abstract_class* create() const = 0;
+ virtual ~a_factory() { }
+ };
+
+ class a_concrete_factory : public a_factory
+ {
+ public:
+ virtual an_abstract_class* create() const
+ {
+ return new a_concrete_class();
+ }
+ };
+
+ class another_concrete_factory : public a_factory
+ {
+ public:
+ virtual an_abstract_class* create() const
+ {
+ return new another_concrete_class();
+ }
+ };
+
+ // [...]
+
+ int main()
+ {
+ __boost__ptr_map__<__std__string__,a_factory> factories;
+
+ // [...]
+
+ factories.insert("a_name",std::auto_ptr<a_factory>(
+ new a_concrete_factory));
+ factories.insert("another_name",std::auto_ptr<a_factory>(
+ new another_concrete_factory));
+
+ // [...]
+
+ std::auto_ptr<an_abstract_class> x(factories.at(some_name).create());
+
+ // [...]
+ }
+
+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:
+
+* We may want a factory that takes some arguments that are forwarded to
+ the constructor,
+* we will probably want to use smart pointers,
+* we may want several member functions to create different kinds of
+ objects,
+* we might not necessarily need a polymorphic base class for the objects,
+* as we will see, we do not need a factory base class at all,
+* we might want to just call the constructor - without `new` to create
+ an object on the stack, and
+* finally we might want to use customized memory management.
+
+Experience has shown that using function objects and generic Boost components
+for their composition, Design Patterns that describe callback mechanisms
+(typically requiring a high percentage of boilerplate code with pure Object
+Oriented methodology) become implementable with just few code lines and without
+extra classes.
+
+Factories are callback mechanisms for constructors, so we provide two class
+templates, __boost__value_factory__ and __boost__factory__, that encapsulate
+object construction via direct application of the constructor and the `new`
+operator, respectively.
+
+We let the function objects forward their arguments to the construction
+expressions they encapsulate. Over this __boost__factory__ optionally allows
+the use of smart pointers and __std_allocators__.
+
+Compile-time polymorphism can be used where appropriate,
+
+ template< class T >
+ void do_something()
+ {
+ // [...]
+ T x = T(a,b);
+
+ // for conceptually similar objects x we neither need virtual
+ // functions nor a common base class in this context.
+ // [...]
+ }
+
+Now, to allow inhomogeneous signatures for the constructors of the types passed
+in for `T` we can use __value_factory__ and __boost__bind__ to normalize between
+them.
+
+ template< class ValueFactory >
+ void do_something(ValueFactory make_obj = ValueFactory())
+ {
+ // [...]
+ typename ValueFactory::result_type x = make_obj(a,b);
+
+ // for conceptually similar objects x we neither need virtual
+ // functions nor a common base class in this context.
+ // [...]
+ }
+
+ int main()
+ {
+ // [...]
+
+ do_something(__boost__value_factory__<X>());
+ do_something(boost::bind(__boost__value_factory__<Y>(),_1,5,_2));
+ // construct X(a,b) and Y(a,5,b), respectively.
+
+ // [...]
+ }
+
+Maybe we want our objects to outlive the function's scope, in this case we
+have to use dynamic allocation;
+
+ template< class Factory >
+ whatever do_something(Factory new_obj = Factory())
+ {
+ typename Factory::result_type ptr = new_obj(a,b);
+
+ // again, no common base class or virtual functions needed,
+ // we could enforce a polymorphic base by writing e.g.
+ // boost::shared_ptr<base>
+ // instead of
+ // typename Factory::result_type
+ // above.
+ // Note that we are also free to have the type erasure happen
+ // somewhere else (e.g. in the constructor of this function's
+ // result type).
+
+ // [...]
+ }
+
+ // [... call do_something like above but with __factory__ instead
+ // of __value_factory__]
+
+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 __boost_function__ to do so. The first example can be rewritten as
+follows.
+
+ typedef boost::function< an_abstract_class*() > a_factory;
+
+ // [...]
+
+ int main()
+ {
+ __std__map__<__std__string__,a_factory> factories;
+
+ // [...]
+
+ factories["a_name"] = __boost__factory__<a_concrete_class*>();
+ factories["another_name"] =
+ __boost__factory__<another_concrete_class*>();
+
+ // [...]
+ }
+
+Of course we can just as easy create factories that take arguments and/or
+return __smart_pointers__.
+
+[endsect]
+
+
+[section:reference Reference]
+
+
+[section value_factory]
+
+[heading Description]
+
+Function object template that invokes the constructor of the type `T`.
+
+[heading Header]
+ #include <boost/functional/value_factory.hpp>
+
+[heading Synopsis]
+
+ namespace boost
+ {
+ template< typename T >
+ class value_factory;
+ }
+
+[variablelist Notation
+ [[`T`] [an arbitrary type with at least one public constructor]]
+ [[`a0`...`aN`] [argument LValues to a constructor of `T`]]
+ [[`F`] [the type `value_factory<F>`]]
+ [[`f`] [an instance object of `F`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression] [Semantics]]
+ [[`F()`] [creates an object of type `F`.]]
+ [[`F(f)`] [creates an object of type `F`.]]
+ [[`f(a0`...`aN)`] [returns `T(a0`...`aN)`.]]
+ [[`F::result_type`] [is the type `T`.]]
+]
+
+[heading Limits]
+
+The macro BOOST_FUNCTIONAL_VALUE_FACTORY_MAX_ARITY can be defined to set the
+maximum arity. It defaults to 10.
+
+[endsect]
+
+
+[section factory]
+
+[heading Description]
+
+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 `boost::pointee<Pointer>::type` yields
+the pointee type.
+
+If an __allocator__ is given, it is used for memory allocation and the
+placement form of the `new` 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 `Pointer` (thus it must be a __smart_pointer__ that provides a suitable
+constructor, such as __boost__shared_ptr__).
+
+If a third template argument is `factory_passes_alloc_to_smart_pointer`,
+the allocator itself is used for the third constructor argument of `Pointer`
+(__boost__shared_ptr__ then uses the allocator to manage the memory of its
+separately allocated reference counter).
+
+[heading Header]
+ #include <boost/functional/factory.hpp>
+
+[heading Synopsis]
+
+ namespace boost
+ {
+ enum factory_alloc_propagation
+ {
+ factory_alloc_for_pointee_and_deleter,
+ factory_passes_alloc_to_smart_pointer
+ };
+
+ template< typename Pointer,
+ class Allocator = boost::none_t,
+ factory_alloc_propagation AllocProp =
+ factory_alloc_for_pointee_and_deleter >
+ class factory;
+ }
+
+[variablelist Notation
+ [[`T`] [an arbitrary type with at least one public constructor]]
+ [[`P`] [pointer or smart pointer to `T`]]
+ [[`a0`...`aN`] [argument LValues to a constructor of `T`]]
+ [[`F`] [the type `factory<P>`]]
+ [[`f`] [an instance object of `F`]]
+]
+
+[heading Expression Semantics]
+
+[table
+ [[Expression] [Semantics]]
+ [[`F()`] [creates an object of type `F`.]]
+ [[`F(f)`] [creates an object of type `F`.]]
+ [[`f(a0`...`aN)`] [dynamically creates an object of type `T` using
+ `a0`...`aN` as arguments for the constructor invocation.]]
+ [[`F::result_type`] [is the type `P` with top-level cv-qualifiers removed.]]
+]
+
+[heading Limits]
+
+The macro BOOST_FUNCTIONAL_FACTORY_MAX_ARITY can be defined to set the
+maximum arity. It defaults to 10.
+
+[endsect]
+
+[endsect]
+
+[section Acknowledgements]
+
+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.
+
+Dave Abrahams suggested Smart Pointer support for exception safety, providing
+useful hints for the implementation.
+
+Joel de Guzman's documentation style was copied from Fusion.
+
+Further, I want to thank Peter Dimov for sharing his insights on language
+details and their evolution.
+
+[endsect]
+
+[section References]
+
+# [@http://en.wikipedia.org/wiki/Design_Patterns Design Patterns],
+ Gamma et al. - Addison Wesley Publishing, 1995
+
+# [@http://www.sgi.com/tech/stl/ Standard Template Library Programmer's Guide],
+ Hewlett-Packard Company, 1994
+
+# [@http://www.boost.org/libs/bind/bind.html Boost.Bind],
+ Peter Dimov, 2001-2005
+
+# [@http://www.boost.org/doc/html/function.html Boost.Function],
+ Douglas Gregor, 2001-2004
+
+[endsect]
+
+
diff --git a/libs/functional/factory/doc/html/index.html b/libs/functional/factory/doc/html/index.html
new file mode 100644
index 0000000..1131629
--- /dev/null
+++ b/libs/functional/factory/doc/html/index.html
@@ -0,0 +1,620 @@
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
+<title>Chapter 1. Boost.Functional/Factory 1.0</title>
+<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
+<meta name="generator" content="DocBook XSL Stylesheets V1.78.1">
+<link rel="home" 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">
+<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="boost_functional_factory.legal"></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 class="toc">
+<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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_functional_factory.brief_description"></a><a class="link" 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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_functional_factory.background"></a><a class="link" 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</span><span class="special">::</span><span class="identifier">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_class</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">at</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>
+<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
+<li class="listitem">
+ We may want a factory that takes some arguments that are forwarded to the
+ constructor,
+ </li>
+<li class="listitem">
+ we will probably want to use smart pointers,
+ </li>
+<li class="listitem">
+ we may want several member functions to create different kinds of objects,
+ </li>
+<li class="listitem">
+ we might not necessarily need a polymorphic base class for the objects,
+ </li>
+<li class="listitem">
+ as we will see, we do not need a factory base class at all,
+ </li>
+<li class="listitem">
+ we might want to just call the constructor - without <code class="computeroutput"><span class="keyword">new</span></code>
+ to create an object on the stack, and
+ </li>
+<li class="listitem">
+ finally we might want to use customized memory management.
+ </li>
+</ul></div>
+<p>
+ Experience has shown that using function objects and generic Boost components
+ for their composition, Design Patterns that describe callback mechanisms (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 encapsulate 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. Over this <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 inhomogeneous signatures 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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_functional_factory.reference"></a><a class="link" href="index.html#boost_functional_factory.reference" title="Reference">Reference</a>
+</h2></div></div></div>
+<div class="toc"><dl class="toc">
+<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">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_functional_factory.reference.value_factory"></a><a class="link" href="index.html#boost_functional_factory.reference.value_factory" title="value_factory">value_factory</a>
+</h3></div></div></div>
+<h5>
+<a name="boost_functional_factory.reference.value_factory.h0"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.value_factory.description"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.description">Description</a>
+ </h5>
+<p>
+ Function object template that invokes the constructor of the type <code class="computeroutput"><span class="identifier">T</span></code>.
+ </p>
+<h5>
+<a name="boost_functional_factory.reference.value_factory.h1"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.value_factory.header"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.header">Header</a>
+ </h5>
+<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>
+<h5>
+<a name="boost_functional_factory.reference.value_factory.h2"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.value_factory.synopsis"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.synopsis">Synopsis</a>
+ </h5>
+<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 class="variablelist">
+<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>
+<h5>
+<a name="boost_functional_factory.reference.value_factory.h3"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.value_factory.expression_semantics"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.expression_semantics">Expression
+ Semantics</a>
+ </h5>
+<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>
+<h5>
+<a name="boost_functional_factory.reference.value_factory.h4"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.value_factory.limits"></a></span><a class="link" href="index.html#boost_functional_factory.reference.value_factory.limits">Limits</a>
+ </h5>
+<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">
+<div class="titlepage"><div><div><h3 class="title">
+<a name="boost_functional_factory.reference.factory"></a><a class="link" href="index.html#boost_functional_factory.reference.factory" title="factory">factory</a>
+</h3></div></div></div>
+<h5>
+<a name="boost_functional_factory.reference.factory.h0"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.factory.description"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.description">Description</a>
+ </h5>
+<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 <a href="http://www.sgi.com/tech/stl/concepts/allocator.html" target="_top">Allocator</a>
+ 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 <a href="http://www.boost.org/libs/smart_ptr/index.html" target="_top">Smart Pointer</a>
+ 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 separately allocated reference counter).
+ </p>
+<h5>
+<a name="boost_functional_factory.reference.factory.h1"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.factory.header"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.header">Header</a>
+ </h5>
+<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>
+<h5>
+<a name="boost_functional_factory.reference.factory.h2"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.factory.synopsis"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.synopsis">Synopsis</a>
+ </h5>
+<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 class="variablelist">
+<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>
+<h5>
+<a name="boost_functional_factory.reference.factory.h3"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.factory.expression_semantics"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.expression_semantics">Expression
+ Semantics</a>
+ </h5>
+<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>
+<h5>
+<a name="boost_functional_factory.reference.factory.h4"></a>
+ <span class="phrase"><a name="boost_functional_factory.reference.factory.limits"></a></span><a class="link" href="index.html#boost_functional_factory.reference.factory.limits">Limits</a>
+ </h5>
+<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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_functional_factory.acknowledgements"></a><a class="link" 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">
+<div class="titlepage"><div><div><h2 class="title" style="clear: both">
+<a name="boost_functional_factory.references"></a><a class="link" href="index.html#boost_functional_factory.references" title="References">References</a>
+</h2></div></div></div>
+<div class="orderedlist"><ol class="orderedlist" type="1">
+<li class="listitem">
+ <a href="http://en.wikipedia.org/wiki/Design_Patterns" target="_top">Design Patterns</a>,
+ Gamma et al. - Addison Wesley Publishing, 1995
+ </li>
+<li class="listitem">
+ <a href="http://www.sgi.com/tech/stl/" target="_top">Standard Template Library Programmer's
+ Guide</a>, Hewlett-Packard Company, 1994
+ </li>
+<li class="listitem">
+ <a href="http://www.boost.org/libs/bind/bind.html" target="_top">Boost.Bind</a>,
+ Peter Dimov, 2001-2005
+ </li>
+<li class="listitem">
+ <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>
diff --git a/libs/functional/factory/doc/html/standalone_HTML.manifest b/libs/functional/factory/doc/html/standalone_HTML.manifest
new file mode 100644
index 0000000..dcaf716
--- /dev/null
+++ b/libs/functional/factory/doc/html/standalone_HTML.manifest
@@ -0,0 +1 @@
+index.html