feedc0de/boost_fusion
1
0
Fork 0
forked from boostorg/fusion
Code Pull Requests Activity
Files
5b6d08974e51db0269537186a13c8ac5b910df05
boost_fusion/doc/html/fusion/quick_start.html
T
Eric Niebler 5b6d08974e Merged revisions 40861-40888 via svnmerge from 
https://svn.boost.org/svn/boost/trunk

........
  r40862 | dave | 2007-11-06 15:39:09 -0800 (Tue, 06 Nov 2007) | 2 lines
  
  Added missing copyright/license
........
  r40863 | djowel | 2007-11-06 18:12:28 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added copyright and license info for each page.
........
  r40864 | aaron_windsor | 2007-11-06 18:30:38 -0800 (Tue, 06 Nov 2007) | 1 line
  
  Shortening file name of a graph test to < 32 characters
........
  r40865 | djowel | 2007-11-06 18:34:18 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added license info in copyright notice at the footer
........
  r40866 | djowel | 2007-11-06 19:06:23 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added license info in copyright notice at the footer
........
  r40867 | djowel | 2007-11-06 19:23:31 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added license info in copyright notice at the footer
........
  r40868 | djowel | 2007-11-06 19:25:59 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added copyright and license info for each page.
........
  r40869 | djowel | 2007-11-06 19:27:38 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added license info in copyright notice at the footer
........
  r40870 | djowel | 2007-11-06 19:30:01 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added copyright and license info for each page.
........
  r40871 | djowel | 2007-11-06 19:35:49 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added copyright and license info for each page.
........
  r40872 | djowel | 2007-11-06 19:37:51 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added copyright and license info for each page.
........
  r40873 | djowel | 2007-11-06 19:46:23 -0800 (Tue, 06 Nov 2007) | 1 line
  
  added copyright and license info for each page.
........
  r40874 | chris_kohlhoff | 2007-11-06 22:49:36 -0800 (Tue, 06 Nov 2007) | 2 lines
  
  Add copyright notice.
........
  r40875 | chris_kohlhoff | 2007-11-06 22:53:17 -0800 (Tue, 06 Nov 2007) | 2 lines
  
  Add myself as asio maintainer.
........
  r40876 | chris_kohlhoff | 2007-11-06 23:23:53 -0800 (Tue, 06 Nov 2007) | 2 lines
  
  Add asio.
........
  r40877 | joaquin | 2007-11-07 00:45:27 -0800 (Wed, 07 Nov 2007) | 1 line
  
  reapplied change at rev 40284
........
  r40878 | johnmaddock | 2007-11-07 02:07:08 -0800 (Wed, 07 Nov 2007) | 1 line
  
  Ooops, got the pp-logic wrong and disable long double support for all Unix platforms, instead of just Intel on Linux prior to version 10.
........
  r40879 | johnmaddock | 2007-11-07 02:09:50 -0800 (Wed, 07 Nov 2007) | 1 line
  
  Fix calls to fpclassify so they don't trigger macro expansion when fpclassify is a macro.
........
  r40880 | t_schwinger | 2007-11-07 02:14:42 -0800 (Wed, 07 Nov 2007) | 3 lines
  
  adds FunctionTypes
........
  r40881 | johnmaddock | 2007-11-07 03:50:02 -0800 (Wed, 07 Nov 2007) | 1 line
  
  Change test (again) so that the range of values tested matches original test: last change started testing more extreme input values, which caused regressions on Mac OS X.
........
  r40882 | johnmaddock | 2007-11-07 03:59:39 -0800 (Wed, 07 Nov 2007) | 3 lines
  
  Disabled use of long double when BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS is defined.
  Disabled special-double precision error rates when BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS is defined.
........
  r40883 | johnmaddock | 2007-11-07 04:04:01 -0800 (Wed, 07 Nov 2007) | 1 line
  
  Oops get the name of test right!
........
  r40884 | anthonyw | 2007-11-07 04:10:17 -0800 (Wed, 07 Nov 2007) | 1 line
  
  Added missing licence and copyright
........
  r40885 | garcia | 2007-11-07 04:25:16 -0800 (Wed, 07 Nov 2007) | 2 lines
  
  added logging library.
........
  r40886 | garcia | 2007-11-07 05:38:53 -0800 (Wed, 07 Nov 2007) | 2 lines
  
  Exception was accepted.
........
  r40887 | fcacciola | 2007-11-07 06:12:15 -0800 (Wed, 07 Nov 2007) | 1 line
  
  Added explicit failures for newly discovered GCC const ref binding bug (see Ticket #1301)
........


[SVN r40891]
2007-11-07 16:22:38 +00:00

267 lines
25 KiB
HTML
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Quick Start</title>
<link rel="stylesheet" href="../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<link rel="start" href="../index.html" title="Chapter 1. Fusion 2.0">
<link rel="up" href="../index.html" title="Chapter 1. Fusion 2.0">
<link rel="prev" href="introduction.html" title="Introduction">
<link rel="next" href="organization.html" title="Organization">
</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.htm">Home</a></td>
<td align="center"><a href="../../../../libraries.htm">Libraries</a></td>
<td align="center"><a href="../../../../../people/people.htm">People</a></td>
<td align="center"><a href="../../../../../more/faq.htm">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="organization.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="fusion.quick_start"></a><a href="quick_start.html" title="Quick Start">Quick Start</a></h2></div></div></div>
<p>
I assume the reader is already familiar with tuples (<a href="http://www.boost.org/libs/tuple/doc/tuple_users_guide.html" target="_top">Boost.Tuple</a>)
and its ancestor <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></tt>. The tuple is a generalization of <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></tt>
for multiple heterogeneous elements (triples, quadruples, etc.). The tuple
is more or less a synonym for fusion's <tt class="computeroutput"><a href="container/vector.html" title="vector"><tt class="computeroutput"><span class="identifier">vector</span></tt></a></tt>.
</p>
<p>
For starters, we shall include all of Fusion's <a href="sequence.html" title="Sequence">Sequence</a>(s)
<sup>[<a name="id456260" href="#ftn.id456260">1</a>]</sup>
:
</p>
<pre class="programlisting">
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">fusion</span><span class="special">/</span><span class="identifier">sequence</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">fusion</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">sequence</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
Let's begin with a <tt class="computeroutput"><a href="container/vector.html" title="vector"><tt class="computeroutput"><span class="identifier">vector</span></tt></a></tt>
<sup>[<a name="id456427" href="#ftn.id456427">2</a>]</sup>
:
</p>
<pre class="programlisting">
<a href="container/vector.html" title="vector"><tt class="computeroutput"><span class="identifier">vector</span></tt></a><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">char</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">stuff</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="char">'x'</span><span class="special">,</span> <span class="string">"howdy"</span><span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <a href="sequence/intrinsic/functions/at_c.html" title="at_c"><tt class="computeroutput"><span class="identifier">at_c</span></tt></a><span class="special">&lt;</span><span class="number">0</span><span class="special">&gt;(</span><span class="identifier">stuff</span><span class="special">);</span>
<span class="keyword">char</span> <span class="identifier">ch</span> <span class="special">=</span> <a href="sequence/intrinsic/functions/at_c.html" title="at_c"><tt class="computeroutput"><span class="identifier">at_c</span></tt></a><span class="special">&lt;</span><span class="number">1</span><span class="special">&gt;(</span><span class="identifier">stuff</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">s</span> <span class="special">=</span> <a href="sequence/intrinsic/functions/at_c.html" title="at_c"><tt class="computeroutput"><span class="identifier">at_c</span></tt></a><span class="special">&lt;</span><span class="number">2</span><span class="special">&gt;(</span><span class="identifier">stuff</span><span class="special">);</span>
</pre>
<p>
Just replace <tt class="computeroutput"><span class="identifier">tuple</span></tt> for <tt class="computeroutput"><a href="container/vector.html" title="vector"><tt class="computeroutput"><span class="identifier">vector</span></tt></a></tt>
and <tt class="computeroutput"><span class="identifier">get</span></tt> for <tt class="computeroutput"><a href="sequence/intrinsic/functions/at_c.html" title="at_c"><tt class="computeroutput"><span class="identifier">at_c</span></tt></a></tt> and this is exactly like
<a href="http://www.boost.org/libs/tuple/doc/tuple_users_guide.html" target="_top">Boost.Tuple</a>.
Actually, either names can be used interchangeably. Yet, the similarity ends
there. You can do a lot more with Fusion <tt class="computeroutput"><a href="container/vector.html" title="vector"><tt class="computeroutput"><span class="identifier">vector</span></tt></a></tt> or <tt class="computeroutput"><span class="identifier">tuple</span></tt>.
Let's see some examples.
</p>
<a name="fusion.quick_start.print_the_vector_as_xml"></a><h3>
<a name="id456890"></a>
<a href="quick_start.html#fusion.quick_start.print_the_vector_as_xml">Print the vector
as XML</a>
</h3>
<p>
First, let's include the algorithms:
</p>
<pre class="programlisting">
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">fusion</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">fusion</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
Now, let's write a function object that prints XML of the form &lt;type&gt;data&lt;/type&gt;
for each member in the tuple.
</p>
<pre class="programlisting">
<span class="keyword">struct</span> <span class="identifier">print_xml</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span>
<span class="special">&lt;&lt;</span> <span class="char">'&lt;'</span> <span class="special">&lt;&lt;</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">x</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="char">'&gt;'</span>
<span class="special">&lt;&lt;</span> <span class="identifier">x</span>
<span class="special">&lt;&lt;</span> <span class="string">"&lt;/"</span> <span class="special">&lt;&lt;</span> <span class="keyword">typeid</span><span class="special">(</span><span class="identifier">x</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="char">'&gt;'</span>
<span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
</pre>
<p>
Now, finally:
</p>
<pre class="programlisting">
<a href="algorithm/iteration/functions/for_each.html" title="for_each"><tt class="computeroutput"><span class="identifier">for_each</span></tt></a><span class="special">(</span><span class="identifier">stuff</span><span class="special">,</span> <span class="identifier">print_xml</span><span class="special">());</span>
</pre>
<p>
That's it! <tt class="computeroutput"><a href="algorithm/iteration/functions/for_each.html" title="for_each"><tt class="computeroutput"><span class="identifier">for_each</span></tt></a></tt> is a fusion algorithm.
It is a generic algorithm similar to <a href="http://en.wikipedia.org/wiki/Standard_Template_Library" target="_top">STL</a>'s.
It iterates over the sequence and calls a user supplied function. In our case,
it calls <tt class="computeroutput"><span class="identifier">print_xml</span></tt>'s <tt class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></tt> for
each element in <tt class="computeroutput"><span class="identifier">stuff</span></tt>.
</p>
<div class="caution"><table border="0" summary="Caution">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Caution]" src="../../../../../doc/html/images/caution.png"></td>
<th align="left">Caution</th>
</tr>
<tr><td colspan="2" align="left" valign="top"><p>
The result of <tt class="computeroutput"><span class="keyword">typeid</span><span class="special">(</span><span class="identifier">x</span><span class="special">).</span><span class="identifier">name</span><span class="special">()</span></tt> is platform specific. The code here is
just for exposition. Of course you already know that :-)
</p></td></tr>
</table></div>
<p>
<tt class="computeroutput"><a href="algorithm/iteration/functions/for_each.html" title="for_each"><tt class="computeroutput"><span class="identifier">for_each</span></tt></a></tt> is generic. With
<tt class="computeroutput"><span class="identifier">print_xml</span></tt>, you can use it to
print just about any Fusion <a href="sequence.html" title="Sequence">Sequence</a>.
</p>
<a name="fusion.quick_start.print_only_pointers"></a><h3>
<a name="id457548"></a>
<a href="quick_start.html#fusion.quick_start.print_only_pointers">Print only pointers</a>
</h3>
<p>
Let's get a little cleverer. Say we wish to write a <span class="emphasis"><em>generic</em></span>
function that takes in an arbitrary sequence and XML prints only those elements
which are pointers. Ah, easy. First, let's include the <tt class="computeroutput"><span class="identifier">is_pointer</span></tt>
boost type trait:
</p>
<pre class="programlisting">
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">type_traits</span><span class="special">/</span><span class="identifier">is_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
Then, simply:
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Sequence</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">xml_print_pointers</span><span class="special">(</span><span class="identifier">Sequence</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">seq</span><span class="special">)</span>
<span class="special">{</span>
<a href="algorithm/iteration/functions/for_each.html" title="for_each"><tt class="computeroutput"><span class="identifier">for_each</span></tt></a><span class="special">(</span><a href="algorithm/transformation/functions/filter_if.html" title="filter_if"><tt class="computeroutput"><span class="identifier">filter_if</span></tt></a><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">_</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="identifier">seq</span><span class="special">),</span> <span class="identifier">print_xml</span><span class="special">());</span>
<span class="special">}</span>
</pre>
<p>
<tt class="computeroutput"><a href="algorithm/transformation/functions/filter_if.html" title="filter_if"><tt class="computeroutput"><span class="identifier">filter_if</span></tt></a></tt> is another Fusion
algorithm. It returns a <a href="view/filter_view.html" title="filter_view"><tt class="computeroutput"><span class="identifier">filter_view</span></tt></a>, a conforming Fusion sequence.
This view reflects only those elements that pass the given predicate. In this
case, the predicate is <tt class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">is_pointer</span><span class="special">&lt;</span><span class="identifier">_</span><span class="special">&gt;</span></tt>.
This "filtered view" is then passed to the <a href="algorithm/iteration/functions/for_each.html" title="for_each"><tt class="computeroutput"><span class="identifier">for_each</span></tt></a> algorithm, which then prints
the "filtered view" as XML.
</p>
<p>
Easy, right?
</p>
<a name="fusion.quick_start.associative_tuples"></a><h3>
<a name="id457958"></a>
<a href="quick_start.html#fusion.quick_start.associative_tuples">Associative tuples</a>
</h3>
<p>
Ok, moving on...
</p>
<p>
Apart from <tt class="computeroutput"><a href="container/vector.html" title="vector"><tt class="computeroutput"><span class="identifier">vector</span></tt></a></tt>,
fusion has a couple of other sequence types to choose from. Each sequence has
its own characteristics. We have <tt class="computeroutput"><a href="container/list.html" title="list"><tt class="computeroutput"><span class="identifier">list</span></tt></a></tt>, <tt class="computeroutput"><a href="container/set.html" title="set"><tt class="computeroutput"><span class="identifier">set</span></tt></a></tt>, <tt class="computeroutput"><a href="container/map.html" title="map"><tt class="computeroutput"><span class="identifier">map</span></tt></a></tt>, plus a multitude of <tt class="computeroutput"><span class="identifier">views</span></tt> that provide various ways to present
the sequences.
</p>
<p>
Fusion's <tt class="computeroutput"><a href="container/map.html" title="map"><tt class="computeroutput"><span class="identifier">map</span></tt></a></tt>
associate types with elements. It can be used as a cleverer replacement of
the <tt class="computeroutput"><span class="keyword">struct</span></tt>. Example:
</p>
<pre class="programlisting">
<span class="keyword">namespace</span> <span class="identifier">fields</span>
<span class="special">{</span>
<span class="keyword">struct</span> <span class="identifier">name</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">age</span><span class="special">;</span>
<span class="special">}</span>
<span class="keyword">typedef</span> <a href="container/map.html" title="map"><tt class="computeroutput"><span class="identifier">map</span></tt></a><span class="special">&lt;</span>
<a href="support/pair.html" title="pair"><tt class="computeroutput"><span class="identifier">fusion</span><span class="special">::</span><span class="identifier">pair</span></tt></a><span class="special">&lt;</span><span class="identifier">fields</span><span class="special">::</span><span class="identifier">name</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span>
<span class="special">,</span> <a href="support/pair.html" title="pair"><tt class="computeroutput"><span class="identifier">fusion</span><span class="special">::</span><span class="identifier">pair</span></tt></a><span class="special">&lt;</span><span class="identifier">fields</span><span class="special">::</span><span class="identifier">age</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span>
<span class="identifier">person</span><span class="special">;</span>
</pre>
<p>
<tt class="computeroutput"><a href="container/map.html" title="map"><tt class="computeroutput"><span class="identifier">map</span></tt></a></tt>
is an associative sequence. Its elements are Fusion pairs which differ somewhat
from <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></tt>. Fusion pairs only contain one member,
with the type of their second template parameter. The first type parameter
of the pair is used as an index to the associated element in the sequence.
For example, given a <tt class="computeroutput"><span class="identifier">a_person</span></tt>
of type, <tt class="computeroutput"><span class="identifier">person</span></tt>, you can do:
</p>
<pre class="programlisting">
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">fields</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">person_name</span> <span class="special">=</span> <a href="sequence/intrinsic/functions/at_key.html" title="at_key"><tt class="computeroutput"><span class="identifier">at_key</span></tt></a><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;(</span><span class="identifier">a_person</span><span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">person_age</span> <span class="special">=</span> <a href="sequence/intrinsic/functions/at_key.html" title="at_key"><tt class="computeroutput"><span class="identifier">at_key</span></tt></a><span class="special">&lt;</span><span class="identifier">age</span><span class="special">&gt;(</span><span class="identifier">a_person</span><span class="special">);</span>
</pre>
<p>
Why go through all this trouble, you say? Well, for one, unlike the <tt class="computeroutput"><span class="keyword">struct</span></tt>, we are dealing with a generic data structure.
There are a multitude of facilities available at your disposal provided out
of the box with fusion or written by others. With these facilities, introspection
comes for free, for example. We can write one serialization function (well,
two, if you consider loading and saving) that will work for all your fusion
<tt class="computeroutput"><a href="container/map.html" title="map"><tt class="computeroutput"><span class="identifier">map</span></tt></a></tt>s.
Example:
</p>
<pre class="programlisting">
<span class="keyword">struct</span> <span class="identifier">saver</span>
<span class="special">{</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Pair</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">Pair</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">data</span><span class="special">)</span> <span class="keyword">const</span>
<span class="special">{</span>
<span class="identifier">some_archive</span> <span class="special">&lt;&lt;</span> <span class="identifier">data</span><span class="special">.</span><span class="identifier">second</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">};</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Stuff</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">save</span><span class="special">(</span><span class="identifier">Stuff</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">stuff</span><span class="special">)</span>
<span class="special">{</span>
<a href="algorithm/iteration/functions/for_each.html" title="for_each"><tt class="computeroutput"><span class="identifier">for_each</span></tt></a><span class="special">(</span><span class="identifier">stuff</span><span class="special">,</span> <span class="identifier">saver</span><span class="special">());</span>
<span class="special">}</span>
</pre>
<p>
The <tt class="computeroutput"><span class="identifier">save</span></tt> function is generic
and will work for all types of <tt class="computeroutput"><span class="identifier">stuff</span></tt>
regardless if it is a <tt class="computeroutput"><span class="identifier">person</span></tt>,
a <tt class="computeroutput"><span class="identifier">dog</span></tt> or a whole <tt class="computeroutput"><span class="identifier">alternate_universe</span></tt>.
</p>
<a name="fusion.quick_start.tip_of_the_iceberg"></a><h3>
<a name="id459000"></a>
<a href="quick_start.html#fusion.quick_start.tip_of_the_iceberg">Tip of the Iceberg</a>
</h3>
<p>
And... we've barely scratched the surface! You can compose and expand the data
structures, remove elements from the structures, find specific data types,
query the elements, filter out types for inspection, transform data structures,
etc. What you've seen is just the tip of the iceberg.
</p>
<div class="footnotes">
<br><hr width="100" align="left">
<div class="footnote"><p><sup>[<a name="ftn.id456260" href="#id456260">1</a>] </sup>
There are finer grained header files available if you wish to have more
control over which components to include (see section <a href="organization.html" title="Organization">Orgainization</a>
for details).
</p></div>
<div class="footnote"><p><sup>[<a name="ftn.id456427" href="#id456427">2</a>] </sup>
Unless otherwise noted, components are in namespace <tt class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">fusion</span></tt>.
For the sake of simplicity, code in this quick start implies <tt class="computeroutput"><span class="keyword">using</span></tt> directives for the fusion components
we will be using.
</p></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright © 2001-2007 Joel de Guzman, Dan Marsden, Tobias
Schwinger<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></small></div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../doc/html/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/html/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/html/images/home.png" alt="Home"></a><a accesskey="n" href="organization.html"><img src="../../../../../doc/html/images/next.png" alt="Next"></a>
</div>
</body>
</html>
View Git Blame Copy Permalink