boost-react-native-bundle

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII"> <title>Chapter 1. Boost.Functional/Forward 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/Forward 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_forward"></a>Chapter 1. Boost.Functional/Forward 1.0</h2></div> <div><div class="author"><h3 class="author"> Tobias Schwinger </h3></div></div> <div>Copyright © 2007, 2008 Tobias Schwinger</div> <div><div class="legalnotice"> <a name="boost_functional_forward.legal"></a> 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>) </div></div> </div></div> <div class="toc"> Table of Contents <dl class="toc"> <dt><a href="index.html#boost_functional_forward.brief_description">Brief Description</a></dt> <dt><a href="index.html#boost_functional_forward.background">Background</a></dt> <dt><a href="index.html#boost_functional_forward.reference">Reference</a></dt> <dt><a href="index.html#boost_functional_forward.acknowledgements">Acknowledgements</a></dt> <dt><a href="index.html#boost_functional_forward.references">References</a></dt> </dl> </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_functional_forward.brief_description"></a><a class="link" href="index.html#boost_functional_forward.brief_description" title="Brief Description">Brief Description</a> </h2></div></div></div> <code class="computeroutput">boost::forward_adapter</code> provides a reusable adapter template for function objects. It forwards RValues as references to const, while leaving LValues as-is. <pre class="programlisting">struct g // function object that only accept LValues { template< typename T0, typename T1, typename T2 > void operator()(T0 & t0, T1 & t1, T2 & t2) const; typedef void result_type; }; // Adapted version also accepts RValues and forwards // them as references to const, LValues as-is typedef boost::forward_adapter<g> f; </pre> Another adapter, <code class="computeroutput">boost::lighweight_forward_adapter</code> allows forwarding with some help from the user accepting and unwrapping reference wrappers (see <a href="http://www.boost.org/doc/html/ref.html" target="_top">Boost.Ref</a>) for reference arguments, const qualifying all other arguments. The target functions must be compatible with <a href="http://www.boost.org/libs/utility/utility.htm#result_of" target="_top">Boost.ResultOf</a>, and so are the adapters. </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_functional_forward.background"></a><a class="link" href="index.html#boost_functional_forward.background" title="Background">Background</a> </h2></div></div></div> Let's suppose we have some function <code class="computeroutput">f</code> that we can call like this: <pre class="programlisting">f(123,a_variable); </pre> Now we want to write another, generic function <code class="computeroutput">g</code> that can be called the same way and returns some object that calls <code class="computeroutput">f</code> with the same arguments. <pre class="programlisting">f(123,a_variable) == g(f,123,a_variable).call_f() </pre> <h4> <a name="boost_functional_forward.background.h0"></a> <a name="boost_functional_forward.background.why_would_we_want_to_do_it__anyway_"></a><a class="link" href="index.html#boost_functional_forward.background.why_would_we_want_to_do_it__anyway_">Why would we want to do it, anyway?</a> </h4> Maybe we want to run <code class="computeroutput">f</code> several times. Or maybe we want to run it within another thread. Maybe we just want to encapsulate the call expression for now, and then use it with other code that allows to compose more complex expressions in order to decompose it with C++ templates and have the compiler generate some machinery that eventually calls <code class="computeroutput">f</code> at runtime (in other words; apply a technique that is commonly referred to as Expression Templates). <h4> <a name="boost_functional_forward.background.h1"></a> <a name="boost_functional_forward.background.now__how_do_we_do_it_"></a><a class="link" href="index.html#boost_functional_forward.background.now__how_do_we_do_it_">Now, how do we do it?</a> </h4> The bad news is: It's impossible. That is so because there is a slight difference between a variable and an expression that evaluates to its value: Given <pre class="programlisting">int y; int const z = 0; </pre> and <pre class="programlisting">template< typename T > void func1(T & x); </pre> we can call <pre class="programlisting">func1(y); // x is a reference to a non-const object func1(z); // x is a reference to a const object </pre> where <pre class="programlisting">func1(1); // fails to compile. </pre> This way we can safely have <code class="computeroutput">func1</code> store its reference argument and the compiler keeps us from storing a reference to an object with temporary lifetime. It is important to realize that non-constness and whether an object binds to a non-const reference parameter are two different properties. The latter is the distinction between LValues and RValues. The names stem from the left hand side and the right hand side of assignment expressions, thus LValues are typically the ones you can assign to, and RValues the temporary results from the right hand side expression. <pre class="programlisting">y = 1+2; // a is LValue, 1+2 is the expression producing the RValue, // 1+2 = a; // usually makes no sense. func1(y); // works, because y is an LValue // func1(1+2); // fails to compile, because we only got an RValue. </pre> If we add const qualification on the parameter, our function also accepts RValues: <pre class="programlisting">template< typename T > void func2(T const & x); // [...] function scope: func2(1); // x is a reference to a const temporary, object, func2(y); // x is a reference to a const object, while y is not const, and func2(z); // x is a reference to a const object, just like z. </pre> In all cases, the argument <code class="computeroutput">x</code> in <code class="computeroutput">func2</code> is a const-qualified LValue. We can use function overloading to identify non-const LValues: <pre class="programlisting">template< typename T > void func3(T const & x); // #1 template< typename T > void func3(T & x); // #2 // [...] function scope: func3(1); // x is a reference to a const, temporary object in #1, func3(y); // x is a reference to a non-const object in #2, and func3(z); // x is a reference to a const object in #1. </pre> Note that all arguments <code class="computeroutput">x</code> in the overloaded function <code class="computeroutput">func3</code> are LValues. In fact, there is no way to transport RValues into a function as-is in C++98. Also note that we can't distinguish between what used to be a const qualified LValue and an RValue. That's as close as we can get to a generic forwarding function <code class="computeroutput">g</code> as described above by the means of C++ 98. See <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_top">The Forwarding Problem</a> for a very detailed discussion including solutions that require language changes. Now, for actually implementing it, we need 2^N overloads for N parameters (each with and without const qualifier) for each number of arguments (that is 2^(Nmax+1) - 2^Nmin). Right, that means the compile-time complexity is O(2^N), however the factor is low so it works quite well for a reasonable number (< 10) of arguments. </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_functional_forward.reference"></a><a class="link" href="index.html#boost_functional_forward.reference" title="Reference">Reference</a> </h2></div></div></div> <div class="toc"><dl class="toc"> <dt><a href="index.html#boost_functional_forward.reference.forward_adapter">forward_adapter</a></dt> <dt><a href="index.html#boost_functional_forward.reference.lightweight_forward_adapter">lightweight_forward_adapter</a></dt> </dl></div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_functional_forward.reference.forward_adapter"></a><a class="link" href="index.html#boost_functional_forward.reference.forward_adapter" title="forward_adapter">forward_adapter</a> </h3></div></div></div> <h5> <a name="boost_functional_forward.reference.forward_adapter.h0"></a> <a name="boost_functional_forward.reference.forward_adapter.description"></a><a class="link" href="index.html#boost_functional_forward.reference.forward_adapter.description">Description</a> </h5> Function object adapter template whose instances are callable with LValue and RValue arguments. RValue arguments are forwarded as reference-to-const typed LValues. An arity can be given as second, numeric non-type template argument to restrict forwarding to a specific arity. If a third, numeric non-type template argument is present, the second and third template argument are treated as minimum and maximum arity, respectively. Specifying an arity can be helpful to improve the readability of diagnostic messages and compile time performance. <a href="http://www.boost.org/libs/utility/utility.htm#result_of" target="_top">Boost.ResultOf</a> can be used to determine the result types of specific call expressions. <h5> <a name="boost_functional_forward.reference.forward_adapter.h1"></a> <a name="boost_functional_forward.reference.forward_adapter.header"></a><a class="link" href="index.html#boost_functional_forward.reference.forward_adapter.header">Header</a> </h5> <pre class="programlisting">#include <boost/functional/forward_adapter.hpp> </pre> <h5> <a name="boost_functional_forward.reference.forward_adapter.h2"></a> <a name="boost_functional_forward.reference.forward_adapter.synopsis"></a><a class="link" href="index.html#boost_functional_forward.reference.forward_adapter.synopsis">Synopsis</a> </h5> <pre class="programlisting">namespace boost { template< class Function, int Arity_Or_MinArity = unspecified, int MaxArity = unspecified > class forward_adapter; } </pre> <div class="variablelist"> Notation <dl class="variablelist"> <dt><code class="computeroutput">F</code></dt> <dd> a possibly const qualified function object type or reference type thereof </dd> <dt><code class="computeroutput">f</code></dt> <dd> an object convertible to <code class="computeroutput">F</code> </dd> <dt><code class="computeroutput">FA</code></dt> <dd> the type <code class="computeroutput">forward_adapter<F></code> </dd> <dt><code class="computeroutput">fa</code></dt> <dd> an instance object of <code class="computeroutput">FA</code>, initialized with <code class="computeroutput">f</code> </dd> <dt><code class="computeroutput">a0</code>...<code class="computeroutput">aN</code></dt> <dd> arguments to <code class="computeroutput">fa</code> </dd> </dl> </div> The result type of a target function invocation must be <pre class="programlisting"><a href="http://www.boost.org/libs/utility/utility.htm#result_of" target="_top"><code class="computeroutput">boost::result_of</code></a><F*(TA0 [const]&...TAN [const]&])>::type </pre> where <code class="computeroutput">TA0</code>...<code class="computeroutput">TAN</code> denote the argument types of <code class="computeroutput">a0</code>...<code class="computeroutput">aN</code>. <h5> <a name="boost_functional_forward.reference.forward_adapter.h3"></a> <a name="boost_functional_forward.reference.forward_adapter.expression_semantics"></a><a class="link" href="index.html#boost_functional_forward.reference.forward_adapter.expression_semantics">Expression Semantics</a> </h5> <div class="informaltable"><table class="table"> <colgroup> <col> <col> </colgroup> <thead><tr> <th> Expression </th> <th> Semantics </th> </tr></thead> <tbody> <tr> <td> <code class="computeroutput">FA(f)</code> </td> <td> creates an adapter, initializes the target function with <code class="computeroutput">f</code>. </td> </tr> <tr> <td> <code class="computeroutput">FA()</code> </td> <td> creates an adapter, attempts to use <code class="computeroutput">F</code>'s default constructor. </td> </tr> <tr> <td> <code class="computeroutput">fa(a0</code>...<code class="computeroutput">aN)</code> </td> <td> calls <code class="computeroutput">f</code> with with arguments <code class="computeroutput">a0</code>...<code class="computeroutput">aN</code>. </td> </tr> </tbody> </table></div> <h5> <a name="boost_functional_forward.reference.forward_adapter.h4"></a> <a name="boost_functional_forward.reference.forward_adapter.limits"></a><a class="link" href="index.html#boost_functional_forward.reference.forward_adapter.limits">Limits</a> </h5> The macro BOOST_FUNCTIONAL_FORWARD_ADAPTER_MAX_ARITY can be defined to set the maximum call arity. It defaults to 6. <h5> <a name="boost_functional_forward.reference.forward_adapter.h5"></a> <a name="boost_functional_forward.reference.forward_adapter.complexity"></a><a class="link" href="index.html#boost_functional_forward.reference.forward_adapter.complexity">Complexity</a> </h5> Preprocessing time: O(2^N), where N is the arity limit. Compile time: O(2^N), where N depends on the arity range. Run time: O(0) if the compiler inlines, O(1) otherwise. </div> <div class="section"> <div class="titlepage"><div><div><h3 class="title"> <a name="boost_functional_forward.reference.lightweight_forward_adapter"></a><a class="link" href="index.html#boost_functional_forward.reference.lightweight_forward_adapter" title="lightweight_forward_adapter">lightweight_forward_adapter</a> </h3></div></div></div> <h5> <a name="boost_functional_forward.reference.lightweight_forward_adapter.h0"></a> <a name="boost_functional_forward.reference.lightweight_forward_adapter.description"></a><a class="link" href="index.html#boost_functional_forward.reference.lightweight_forward_adapter.description">Description</a> </h5> Function object adapter template whose instances are callable with LValue and RValue arguments. All arguments are forwarded as reference-to-const typed LValues, except for reference wrappers which are unwrapped and may yield non-const LValues. An arity can be given as second, numeric non-type template argument to restrict forwarding to a specific arity. If a third, numeric non-type template argument is present, the second and third template argument are treated as minimum and maximum arity, respectively. Specifying an arity can be helpful to improve the readability of diagnostic messages and compile time performance. <a href="http://www.boost.org/libs/utility/utility.htm#result_of" target="_top">Boost.ResultOf</a> can be used to determine the result types of specific call expressions. <h5> <a name="boost_functional_forward.reference.lightweight_forward_adapter.h1"></a> <a name="boost_functional_forward.reference.lightweight_forward_adapter.header"></a><a class="link" href="index.html#boost_functional_forward.reference.lightweight_forward_adapter.header">Header</a> </h5> <pre class="programlisting">#include <boost/functional/lightweight_forward_adapter.hpp> </pre> <h5> <a name="boost_functional_forward.reference.lightweight_forward_adapter.h2"></a> <a name="boost_functional_forward.reference.lightweight_forward_adapter.synopsis"></a><a class="link" href="index.html#boost_functional_forward.reference.lightweight_forward_adapter.synopsis">Synopsis</a> </h5> <pre class="programlisting">namespace boost { template< class Function, int Arity_Or_MinArity = unspecified, int MaxArity = unspecified > struct lightweight_forward_adapter; } </pre> <div class="variablelist"> Notation <dl class="variablelist"> <dt><code class="computeroutput">F</code></dt> <dd> a possibly const qualified function object type or reference type thereof </dd> <dt><code class="computeroutput">f</code></dt> <dd> an object convertible to <code class="computeroutput">F</code> </dd> <dt><code class="computeroutput">FA</code></dt> <dd> the type <code class="computeroutput">lightweight_forward_adapter<F></code> </dd> <dt><code class="computeroutput">fa</code></dt> <dd> an instance of <code class="computeroutput">FA</code>, initialized with <code class="computeroutput">f</code> </dd> <dt><code class="computeroutput">a0</code>...<code class="computeroutput">aN</code></dt> <dd> arguments to <code class="computeroutput">fa</code> </dd> </dl> </div> The result type of a target function invocation must be <pre class="programlisting"><a href="http://www.boost.org/libs/utility/utility.htm#result_of" target="_top"><code class="computeroutput">boost::result_of</code></a><F*(TA0 [const]&...TAN [const]&])>::type </pre> where <code class="computeroutput">TA0</code>...<code class="computeroutput">TAN</code> denote the argument types of <code class="computeroutput">a0</code>...<code class="computeroutput">aN</code>. <h5> <a name="boost_functional_forward.reference.lightweight_forward_adapter.h3"></a> <a name="boost_functional_forward.reference.lightweight_forward_adapter.expression_semantics"></a><a class="link" href="index.html#boost_functional_forward.reference.lightweight_forward_adapter.expression_semantics">Expression Semantics</a> </h5> <div class="informaltable"><table class="table"> <colgroup> <col> <col> </colgroup> <thead><tr> <th> Expression </th> <th> Semantics </th> </tr></thead> <tbody> <tr> <td> <code class="computeroutput">FA(f)</code> </td> <td> creates an adapter, initializes the target function with <code class="computeroutput">f</code>. </td> </tr> <tr> <td> <code class="computeroutput">FA()</code> </td> <td> creates an adapter, attempts to use <code class="computeroutput">F</code>'s default constructor. </td> </tr> <tr> <td> <code class="computeroutput">fa(a0</code>...<code class="computeroutput">aN)</code> </td> <td> calls <code class="computeroutput">f</code> with with const arguments <code class="computeroutput">a0</code>...<code class="computeroutput">aN</code>. If <code class="computeroutput">aI</code> is a reference wrapper it is unwrapped. </td> </tr> </tbody> </table></div> <h5> <a name="boost_functional_forward.reference.lightweight_forward_adapter.h4"></a> <a name="boost_functional_forward.reference.lightweight_forward_adapter.limits"></a><a class="link" href="index.html#boost_functional_forward.reference.lightweight_forward_adapter.limits">Limits</a> </h5> The macro BOOST_FUNCTIONAL_LIGHTWEIGHT_FORWARD_ADAPTER_MAX_ARITY can be defined to set the maximum call arity. It defaults to 10. <h5> <a name="boost_functional_forward.reference.lightweight_forward_adapter.h5"></a> <a name="boost_functional_forward.reference.lightweight_forward_adapter.complexity"></a><a class="link" href="index.html#boost_functional_forward.reference.lightweight_forward_adapter.complexity">Complexity</a> </h5> Preprocessing time: O(N), where N is the arity limit. Compile time: O(N), where N is the effective arity of a call. Run time: O(0) if the compiler inlines, O(1) otherwise. </div> </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_functional_forward.acknowledgements"></a><a class="link" href="index.html#boost_functional_forward.acknowledgements" title="Acknowledgements">Acknowledgements</a> </h2></div></div></div> As these utilities are factored out of the <a href="http://www.boost.org/libs/fusion/doc/html/index.html" target="_top">Boost.Fusion</a> functional module, I want to thank Dan Marsden and Joel de Guzman for letting me participate in the development of that great library in the first place. Further, I want to credit the authors of the references below, for their in-depth investigation of the problem and the solution implemented here. Last but not least I want to thank Vesa Karnoven and Paul Mensonides for the Boost Preprocessor library. Without it, I would have ended up with an external code generator for this one. </div> <div class="section"> <div class="titlepage"><div><div><h2 class="title" style="clear: both"> <a name="boost_functional_forward.references"></a><a class="link" href="index.html#boost_functional_forward.references" title="References">References</a> </h2></div></div></div> <div class="orderedlist"><ol class="orderedlist" type="1"> <li class="listitem"> <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_top">The Forwarding Problem</a>, Peter Dimov, Howard E. Hinnant, David Abrahams, 2002 </li> <li class="listitem"> <a href="http://www.boost.org/libs/utility/utility.htm#result_of" target="_top">Boost.ResultOf</a>, Douglas Gregor, 2004 </li> <li class="listitem"> <a href="http://www.boost.org/doc/html/ref.html" target="_top">Boost.Ref</a>, Jaakko Jarvi, Peter Dimov, Douglas Gregor, David Abrahams, 1999-2002 </li> </ol></div> </div> </div> <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr> <td align="left">Last revised: November 01, 2008 at 19:58:50 GMT</td> <td align="right"><div class="copyright-footer"></div></td> </tr></table> <hr> <div class="spirit-nav"></div> </body> </html>