ceph/src/boost/libs/bimap/doc/html/boost_bimap/bimap_and_boost/boost_libraries_that_work_well_with_boost_bimap.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Boost Libraries that work well with Boost.Bimap</title>
   5 <link rel="stylesheet" href="../../boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.77.1">
   7 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Bimap">
   8 <link rel="up" href="../bimap_and_boost.html" title="Bimap and Boost">
   9 <link rel="prev" href="../bimap_and_boost.html" title="Bimap and Boost">
  10 <link rel="next" href="dependencies.html" title="Dependencies">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
  15 <td align="center"><a href="../../../../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="../bimap_and_boost.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../bimap_and_boost.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap">
  26 <div class="titlepage"><div><div><h3 class="title">
  27 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html" title="Boost Libraries that work well with Boost.Bimap">Boost
  28       Libraries that work well with Boost.Bimap</a>
  29 </h3></div></div></div>
  30 <div class="toc"><dl>
  31 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.introduction">Introduction</a></span></dt>
  32 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization">Boost.Serialization</a></span></dt>
  33 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_assign">Boost.Assign</a></span></dt>
  34 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_hash">Boost.Hash</a></span></dt>
  35 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_lambda">Boost.Lambda</a></span></dt>
  36 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_range">Boost.Range</a></span></dt>
  37 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_foreach">Boost.Foreach</a></span></dt>
  38 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_typeof">Boost.Typeof</a></span></dt>
  39 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_xpressive">Boost.Xpressive</a></span></dt>
  40 <dt><span class="section"><a href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_property_map">Boost.Property_map</a></span></dt>
  41 </dl></div>
  42 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_introduction">
  43 <div class="titlepage"><div><div><h4 class="title">
  44 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.introduction"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.introduction" title="Introduction">Introduction</a>
  45 </h4></div></div></div>
  46 <div class="informaltable"><table class="table">
  47 <colgroup>
  48 <col>
  49 <col>
  50 <col>
  51 <col>
  52 </colgroup>
  53 <thead><tr>
  54 <th>
  55                   <p>
  56                     Name
  57                   </p>
  58                 </th>
  59 <th>
  60                   <p>
  61                     Description
  62                   </p>
  63                 </th>
  64 <th>
  65                   <p>
  66                     author
  67                   </p>
  68                 </th>
  69 <th>
  70                   <p>
  71                     Purpose
  72                   </p>
  73                 </th>
  74 </tr></thead>
  75 <tbody>
  76 <tr>
  77 <td>
  78                   <p>
  79                     <a href="http://www.boost.org/libs/serialization/doc/index.html" target="_top"><span class="bold"><strong>Boost.Serialization</strong></span></a>
  80                   </p>
  81                 </td>
  82 <td>
  83                   <p>
  84                     Serialization for persistence and marshalling
  85                   </p>
  86                 </td>
  87 <td>
  88                   <p>
  89                     Robert Ramey
  90                   </p>
  91                 </td>
  92 <td>
  93                   <p>
  94                     Serialization support for bimap containers and iterators
  95                   </p>
  96                 </td>
  97 </tr>
  98 <tr>
  99 <td>
 100                   <p>
 101                     <a href="http://www.boost.org/libs/assign/doc/index.html" target="_top"><span class="bold"><strong>Boost.Assign</strong></span></a>
 102                   </p>
 103                 </td>
 104 <td>
 105                   <p>
 106                     Filling containers with constant or generated data has never
 107                     been easier
 108                   </p>
 109                 </td>
 110 <td>
 111                   <p>
 112                     Thorsten Ottosen
 113                   </p>
 114                 </td>
 115 <td>
 116                   <p>
 117                     Help to fill a bimap or views of it
 118                   </p>
 119                 </td>
 120 </tr>
 121 <tr>
 122 <td>
 123                   <p>
 124                     <a href="http://www.boost.org/doc/html/hash.html" target="_top"><span class="bold"><strong>Boost.Hash</strong></span></a>
 125                   </p>
 126                 </td>
 127 <td>
 128                   <p>
 129                     A TR1 hash function object that can be extended to hash user
 130                     defined types
 131                   </p>
 132                 </td>
 133 <td>
 134                   <p>
 135                     Daniel James
 136                   </p>
 137                 </td>
 138 <td>
 139                   <p>
 140                     Default hashing function
 141                   </p>
 142                 </td>
 143 </tr>
 144 <tr>
 145 <td>
 146                   <p>
 147                     <a href="http://www.boost.org/doc/html/lambda.html" target="_top"><span class="bold"><strong>Boost.Lambda</strong></span></a>
 148                   </p>
 149                 </td>
 150 <td>
 151                   <p>
 152                     Define small unnamed function objects at the actual call site,
 153                     and more
 154                   </p>
 155                 </td>
 156 <td>
 157                   <p>
 158                     from Jaakko J&#228;rvi, Gary Powell
 159                   </p>
 160                 </td>
 161 <td>
 162                   <p>
 163                     Functors for modify, range, lower_bound and upper_bound
 164                   </p>
 165                 </td>
 166 </tr>
 167 <tr>
 168 <td>
 169                   <p>
 170                     <a href="http://www.boost.org/doc/html/range.html" target="_top"><span class="bold"><strong>Boost.Range</strong></span></a>
 171                   </p>
 172                 </td>
 173 <td>
 174                   <p>
 175                     A new infrastructure for generic algorithms that builds on top
 176                     of the new iterator concepts
 177                   </p>
 178                 </td>
 179 <td>
 180                   <p>
 181                     Thorsten Ottosen
 182                   </p>
 183                 </td>
 184 <td>
 185                   <p>
 186                     Range based algorithms
 187                   </p>
 188                 </td>
 189 </tr>
 190 <tr>
 191 <td>
 192                   <p>
 193                     <a href="http://www.boost.org/doc/html/foreach.html" target="_top"><span class="bold"><strong>Boost.Foreach</strong></span></a>
 194                   </p>
 195                 </td>
 196 <td>
 197                   <p>
 198                     BOOST_FOREACH macro for easily iterating over the elements of
 199                     a sequence
 200                   </p>
 201                 </td>
 202 <td>
 203                   <p>
 204                     Eric Niebler
 205                   </p>
 206                 </td>
 207 <td>
 208                   <p>
 209                     Iteration
 210                   </p>
 211                 </td>
 212 </tr>
 213 <tr>
 214 <td>
 215                   <p>
 216                     <a href="http://www.boost.org/libs/typeof/doc/index.html" target="_top"><span class="bold"><strong>Boost.Typeof</strong></span></a>
 217                   </p>
 218                 </td>
 219 <td>
 220                   <p>
 221                     Typeof operator emulation
 222                   </p>
 223                 </td>
 224 <td>
 225                   <p>
 226                     Arkadiy Vertleyb, Peder Holt
 227                   </p>
 228                 </td>
 229 <td>
 230                   <p>
 231                     Using BOOST_AUTO while we wait for C++0x
 232                   </p>
 233                 </td>
 234 </tr>
 235 <tr>
 236 <td>
 237                   <p>
 238                     <a href="http://www.boost.org/libs/xpressive/doc/index.html" target="_top"><span class="bold"><strong>Boost.Xpressive</strong></span></a>
 239                   </p>
 240                 </td>
 241 <td>
 242                   <p>
 243                     Regular expressions that can be written as strings or as expression
 244                     templates
 245                   </p>
 246                 </td>
 247 <td>
 248                   <p>
 249                     Eric Niebler
 250                   </p>
 251                 </td>
 252 <td>
 253                   <p>
 254                     Help to fill a bimap from a string
 255                   </p>
 256                 </td>
 257 </tr>
 258 <tr>
 259 <td>
 260                   <p>
 261                     <a href="http://www.boost.org/doc/html/property_map.html" target="_top"><span class="bold"><strong>Boost.PropertyMap</strong></span></a>
 262                   </p>
 263                 </td>
 264 <td>
 265                   <p>
 266                     Concepts defining interfaces which map key objects to value objects
 267                   </p>
 268                 </td>
 269 <td>
 270                   <p>
 271                     Jeremy Siek
 272                   </p>
 273                 </td>
 274 <td>
 275                   <p>
 276                     Integration with BGL
 277                   </p>
 278                 </td>
 279 </tr>
 280 </tbody>
 281 </table></div>
 282 </div>
 283 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_serialization">
 284 <div class="titlepage"><div><div><h4 class="title">
 285 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization" title="Boost.Serialization">Boost.Serialization</a>
 286 </h4></div></div></div>
 287 <p>
 288           A bimap can be archived and retrieved by means of the Boost.Serialization
 289           Library. Both regular and XML archives are supported. The usage is straightforward
 290           and does not differ from that of any other serializable type. For instance:
 291         </p>
 292 <p>
 293           <a href="../../../../example/bimap_and_boost/serialization.cpp" target="_top">Go to source
 294           code</a>
 295         </p>
 296 <p>
 297 </p>
 298 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">&gt;</span> <span class="identifier">bm_type</span><span class="special">;</span>
 299
 300 <span class="comment">// Create a bimap and serialize it to a file</span>
 301 <span class="special">{</span>
 302     <span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
 303     <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"one"</span><span class="special">,</span><span class="number">1</span><span class="special">)</span> <span class="special">);</span>
 304     <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"two"</span><span class="special">,</span><span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 305
 306     <span class="identifier">std</span><span class="special">::</span><span class="identifier">ofstream</span> <span class="identifier">ofs</span><span class="special">(</span><span class="string">"data"</span><span class="special">);</span>
 307     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">archive</span><span class="special">::</span><span class="identifier">text_oarchive</span> <span class="identifier">oa</span><span class="special">(</span><span class="identifier">ofs</span><span class="special">);</span>
 308
 309     <span class="identifier">oa</span> <span class="special">&lt;&lt;</span> <span class="keyword">const_cast</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">bm_type</span><span class="special">&amp;&gt;(</span><span class="identifier">bm</span><span class="special">);</span> <a class="co" name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c0" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c1"><img src="../../../../../../doc/src/images/callouts/1.png" alt="1" border="0"></a>
 310
 311     <a class="co" name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c2" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c3"><img src="../../../../../../doc/src/images/callouts/2.png" alt="2" border="0"></a><span class="keyword">const</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">left_iterator</span> <span class="identifier">left_iter</span> <span class="special">=</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="string">"two"</span><span class="special">);</span>
 312     <span class="identifier">oa</span> <span class="special">&lt;&lt;</span> <span class="identifier">left_iter</span><span class="special">;</span>
 313
 314     <span class="keyword">const</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">right_iterator</span> <span class="identifier">right_iter</span> <span class="special">=</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="number">1</span><span class="special">);</span>
 315     <span class="identifier">oa</span> <span class="special">&lt;&lt;</span> <span class="identifier">right_iter</span><span class="special">;</span>
 316 <span class="special">}</span>
 317
 318 <span class="comment">// Load the bimap back</span>
 319 <span class="special">{</span>
 320     <span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
 321
 322     <span class="identifier">std</span><span class="special">::</span><span class="identifier">ifstream</span> <span class="identifier">ifs</span><span class="special">(</span><span class="string">"data"</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ios</span><span class="special">::</span><span class="identifier">binary</span><span class="special">);</span>
 323     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">archive</span><span class="special">::</span><span class="identifier">text_iarchive</span> <span class="identifier">ia</span><span class="special">(</span><span class="identifier">ifs</span><span class="special">);</span>
 324
 325     <span class="identifier">ia</span> <span class="special">&gt;&gt;</span> <span class="identifier">bm</span><span class="special">;</span>
 326
 327     <span class="identifier">assert</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">2</span> <span class="special">);</span>
 328
 329     <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">left_iterator</span> <span class="identifier">left_iter</span><span class="special">;</span>
 330     <span class="identifier">ia</span> <span class="special">&gt;&gt;</span> <span class="identifier">left_iter</span><span class="special">;</span>
 331
 332     <span class="identifier">assert</span><span class="special">(</span> <span class="identifier">left_iter</span><span class="special">-&gt;</span><span class="identifier">first</span> <span class="special">==</span> <span class="string">"two"</span> <span class="special">);</span>
 333
 334     <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">right_iterator</span> <span class="identifier">right_iter</span><span class="special">;</span>
 335     <span class="identifier">ia</span> <span class="special">&gt;&gt;</span> <span class="identifier">right_iter</span><span class="special">;</span>
 336
 337     <span class="identifier">assert</span><span class="special">(</span> <span class="identifier">right_iter</span><span class="special">-&gt;</span><span class="identifier">first</span> <span class="special">==</span> <span class="number">1</span> <span class="special">);</span>
 338 <span class="special">}</span>
 339 </pre>
 340 <p>
 341         </p>
 342 <div class="calloutlist"><table border="0" summary="Callout list">
 343 <tr>
 344 <td width="5%" valign="top" align="left"><p><a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c1"></a><a href="#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c0"><img src="../../../../../../doc/src/images/callouts/1.png" alt="1" border="0"></a> </p></td>
 345 <td valign="top" align="left"><p>
 346               We must do a const cast because Boost.Serialization archives only save
 347               const objects. Read Boost.Serializartion docs for the rationale behind
 348               this decision
 349             </p></td>
 350 </tr>
 351 <tr>
 352 <td width="5%" valign="top" align="left"><p><a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c3"></a><a href="#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_serialization.c2"><img src="../../../../../../doc/src/images/callouts/2.png" alt="2" border="0"></a> </p></td>
 353 <td valign="top" align="left"><p>
 354               We can only serialize iterators if the bimap was serialized first.
 355               Note that the const cast is not requiered here because we create our
 356               iterators as const.
 357             </p></td>
 358 </tr>
 359 </table></div>
 360 <p>
 361           Serialization capabilities are automatically provided by just linking with
 362           the appropriate Boost.Serialization library module: it is not necessary
 363           to explicitly include any header from Boost.Serialization, apart from those
 364           declaring the type of archive used in the process. If not used, however,
 365           serialization support can be disabled by globally defining the macro BOOST_BIMAP_DISABLE_SERIALIZATION.
 366           Disabling serialization for Boost.MultiIndex can yield a small improvement
 367           in build times, and may be necessary in those defective compilers that
 368           fail to correctly process Boost.Serialization headers.
 369         </p>
 370 <div class="warning"><table border="0" summary="Warning">
 371 <tr>
 372 <td rowspan="2" align="center" valign="top" width="25"><img alt="[Warning]" src="../../../../../../doc/src/images/warning.png"></td>
 373 <th align="left">Warning</th>
 374 </tr>
 375 <tr><td align="left" valign="top"><p>
 376             Boost.Bimap and Boost.MultiIndex share a lot of serialization code. The
 377             macro <code class="computeroutput"><span class="identifier">BOOST_BIMAP_DISABLE_SERIALIZATION</span></code>
 378             disables serialization in <span class="bold"><strong>both</strong></span> libraries.
 379             The same happens when <code class="computeroutput"><span class="identifier">BOOST_MULTI_INDEX_DISABLE_SERIALIZATION</span></code>
 380             is defined.
 381           </p></td></tr>
 382 </table></div>
 383 <p>
 384           Retrieving an archived bimap restores not only the elements, but also the
 385           order they were arranged in the views of the container. There is an exception
 386           to this rule, though: for unordered sets, no guarantee is made about the
 387           order in which elements will be iterated in the restored container; in
 388           general, it is unwise to rely on the ordering of elements of a hashed view,
 389           since it can change in arbitrary ways during insertion or rehashing --this
 390           is precisely the reason why hashed indices and TR1 unordered associative
 391           containers do not define an equality operator.
 392         </p>
 393 <p>
 394           Iterators of a bimap can also be serialized. Serialization of an iterator
 395           must be done only after serializing its corresponding container.
 396         </p>
 397 </div>
 398 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_assign">
 399 <div class="titlepage"><div><div><h4 class="title">
 400 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_assign"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_assign" title="Boost.Assign">Boost.Assign</a>
 401 </h4></div></div></div>
 402 <p>
 403           The purpose of this library is to make it easy to fill containers with
 404           data by overloading operator,() and operator()(). These two operators make
 405           it possible to construct lists of values that are then copied into a container.
 406         </p>
 407 <p>
 408           These lists are particularly useful in learning, testing, and prototyping
 409           situations, but can also be handy otherwise. The library comes with predefined
 410           operators for the containers of the standard library, but most functionality
 411           will work with any standard compliant container. The library also makes
 412           it possible to extend user defined types so for example a member function
 413           can be called for a list of values instead of its normal arguments.
 414         </p>
 415 <p>
 416           Boost.Assign can be used with bimap containers. The views of a bimap are
 417           signature-compatible with their standard counterparts, so we can use other
 418           Boost.Assign utilities with them.
 419         </p>
 420 <p>
 421           <a href="../../../../example/bimap_and_boost/assign.cpp" target="_top">Go to source code</a>
 422         </p>
 423 <p>
 424 </p>
 425 <pre class="programlisting"> <span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">multiset_of</span><span class="special">&lt;</span> <span class="keyword">int</span> <span class="special">&gt;,</span> <span class="identifier">list_of</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">bm_type</span><span class="special">;</span>
 426
 427  <span class="comment">// We can use assign::list_of to initialize the container.</span>
 428
 429  <span class="identifier">bm_type</span> <span class="identifier">bm</span> <span class="special">=</span> <span class="identifier">assign</span><span class="special">::</span><span class="identifier">list_of</span><span class="special">&lt;</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">relation</span> <span class="special">&gt;</span> <a class="co" name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_assign.c0" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_assign.c1"><img src="../../../../../../doc/src/images/callouts/1.png" alt="1" border="0"></a>
 430      <span class="special">(</span> <span class="number">1</span><span class="special">,</span> <span class="string">"one"</span>   <span class="special">)</span>
 431      <span class="special">(</span> <span class="number">2</span><span class="special">,</span> <span class="string">"two"</span>   <span class="special">)</span>
 432      <span class="special">(</span> <span class="number">3</span><span class="special">,</span> <span class="string">"three"</span> <span class="special">);</span>
 433
 434  <span class="comment">// The left map view is a multiset, again we use insert</span>
 435
 436  <span class="identifier">assign</span><span class="special">::</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span> <span class="special">)</span>
 437      <span class="special">(</span> <span class="number">4</span><span class="special">,</span> <span class="string">"four"</span> <span class="special">)</span>
 438      <span class="special">(</span> <span class="number">5</span><span class="special">,</span> <span class="string">"five"</span> <span class="special">)</span>
 439      <span class="special">(</span> <span class="number">6</span><span class="special">,</span> <span class="string">"six"</span>  <span class="special">);</span>
 440
 441  <span class="comment">// The right map view is a list so we use push_back here</span>
 442  <span class="comment">// Note the order of the elements in the list!</span>
 443
 444  <span class="identifier">assign</span><span class="special">::</span><span class="identifier">push_back</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span> <span class="special">)</span>
 445      <span class="special">(</span> <span class="string">"seven"</span> <span class="special">,</span> <span class="number">7</span> <span class="special">)</span>
 446      <span class="special">(</span> <span class="string">"eight"</span> <span class="special">,</span> <span class="number">8</span> <span class="special">);</span>
 447
 448  <span class="identifier">assign</span><span class="special">::</span><span class="identifier">push_front</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span> <span class="special">)</span>
 449      <span class="special">(</span> <span class="string">"nine"</span>  <span class="special">,</span>  <span class="number">9</span> <span class="special">)</span>
 450      <span class="special">(</span> <span class="string">"ten"</span>   <span class="special">,</span> <span class="number">10</span> <span class="special">)</span>
 451      <span class="special">(</span> <span class="string">"eleven"</span><span class="special">,</span> <span class="number">11</span> <span class="special">);</span>
 452
 453 <span class="comment">// Since it is left_based the main view is a multiset, so we use insert</span>
 454
 455  <span class="identifier">assign</span><span class="special">::</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm</span> <span class="special">)</span>
 456      <span class="special">(</span> <span class="number">12</span><span class="special">,</span> <span class="string">"twelve"</span>   <span class="special">)</span>
 457      <span class="special">(</span> <span class="number">13</span><span class="special">,</span> <span class="string">"thirteen"</span> <span class="special">);</span>
 458 </pre>
 459 <p>
 460         </p>
 461 <div class="calloutlist"><table border="0" summary="Callout list"><tr>
 462 <td width="5%" valign="top" align="left"><p><a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_assign.c1"></a><a href="#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_assign.c0"><img src="../../../../../../doc/src/images/callouts/1.png" alt="1" border="0"></a> </p></td>
 463 <td valign="top" align="left"><p>
 464               Note that <code class="computeroutput"><span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">relation</span></code> has to be used instead of
 465               <code class="computeroutput"><span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span></code>. Contrary to <code class="computeroutput"><span class="identifier">value_type</span></code>, <code class="computeroutput"><span class="identifier">relation</span></code>
 466               type stores the elements as non const, a requirement of <code class="computeroutput"><span class="identifier">assign</span><span class="special">::</span><span class="identifier">list_of</span></code>
 467             </p></td>
 468 </tr></table></div>
 469 </div>
 470 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_hash">
 471 <div class="titlepage"><div><div><h4 class="title">
 472 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_hash"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_hash" title="Boost.Hash">Boost.Hash</a>
 473 </h4></div></div></div>
 474 <p>
 475           The hash function is the very core of the fast lookup capabilities of the
 476           unordered sets: a hasher is just a Unary Function returning an std::size_t
 477           value for any given key. In general, it is impossible that every key map
 478           to a different hash value, for the space of keys can be greater than the
 479           number of permissible hash codes: what makes for a good hasher is that
 480           the probability of a collision (two different keys with the same hash value)
 481           is as close to zero as possible.
 482         </p>
 483 <p>
 484           This is a statistical property depending on the typical distribution of
 485           keys in a given application, so it is not feasible to have a general-purpose
 486           hash function with excellent results in every possible scenario; the default
 487           value for this parameter uses Boost.Hash, which often provides good enough
 488           results.
 489         </p>
 490 <p>
 491           Boost.Hash can be <a href="http://www.boost.org/doc/html/hash/custom.html" target="_top">extended
 492           for custom data types</a>, enabling to use the default parameter of
 493           the unordered set types with any user types.
 494         </p>
 495 </div>
 496 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_lambda">
 497 <div class="titlepage"><div><div><h4 class="title">
 498 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_lambda"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_lambda" title="Boost.Lambda">Boost.Lambda</a>
 499 </h4></div></div></div>
 500 <p>
 501           The Boost Lambda Library (BLL in the sequel) is a C++ template library,
 502           which implements form of lambda abstractions for C++. The term originates
 503           from functional programming and lambda calculus, where a lambda abstraction
 504           defines an unnamed function. Lambda expressions are very useful to construct
 505           the function objects required by some of the functions in a bimap view.
 506         </p>
 507 <p>
 508           Boost.Bimap defines new placeholders in <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bimap</span><span class="special">/</span><span class="identifier">support</span><span class="special">/</span><span class="identifier">lambda</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
 509           to allow a sounder solution. The placeholders are named _key and _data
 510           and both are equivalent to boost::lambda::_1. There are two reasons to
 511           include this placeholders: the code looks better with them and they avoid
 512           the clash problem between lambda::_1 and boost::_1 from Boost.Bind.
 513         </p>
 514 <p>
 515           <a href="../../../../example/bimap_and_boost/lambda.cpp" target="_top">Go to source code</a>
 516         </p>
 517 <p>
 518 </p>
 519 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">&gt;</span> <span class="identifier">bm_type</span><span class="special">;</span>
 520
 521 <span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
 522 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"one"</span><span class="special">,</span><span class="number">1</span><span class="special">)</span> <span class="special">);</span>
 523 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"two"</span><span class="special">,</span><span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 524
 525 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">range</span><span class="special">(</span> <span class="number">5</span> <span class="special">&lt;</span> <span class="identifier">_key</span><span class="special">,</span> <span class="identifier">_key</span> <span class="special">&lt;</span> <span class="number">10</span> <span class="special">);</span>
 526
 527 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">modify_key</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">find</span><span class="special">(</span><span class="string">"one"</span><span class="special">),</span> <span class="identifier">_key</span> <span class="special">=</span> <span class="string">"1"</span> <span class="special">);</span>
 528
 529 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">modify_data</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">_data</span> <span class="special">*=</span> <span class="number">10</span> <span class="special">);</span>
 530 </pre>
 531 <p>
 532         </p>
 533 </div>
 534 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_range">
 535 <div class="titlepage"><div><div><h4 class="title">
 536 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_range"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_range" title="Boost.Range">Boost.Range</a>
 537 </h4></div></div></div>
 538 <p>
 539           Boost.Range is a collection of concepts and utilities that are particularly
 540           useful for specifying and implementing generic algorithms. Generic algorithms
 541           have so far been specified in terms of two or more iterators. Two iterators
 542           would together form a range of values that the algorithm could work on.
 543           This leads to a very general interface, but also to a somewhat clumsy use
 544           of the algorithms with redundant specification of container names. Therefore
 545           we would like to raise the abstraction level for algorithms so they specify
 546           their interface in terms of Ranges as much as possible.
 547         </p>
 548 <p>
 549           As Boost.Bimap views are signature-compatible with their standard container
 550           counterparts, they are compatible with the concept of a range. As an additional
 551           feature, ordered bimap views offer a function named <code class="computeroutput"><span class="identifier">range</span></code>
 552           that allows a range of values to be obtained.
 553         </p>
 554 <p>
 555           If we have some generic functions that accepts ranges:
 556         </p>
 557 <p>
 558 </p>
 559 <pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">ForwardReadableRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryFunctor</span> <span class="special">&gt;</span>
 560 <span class="identifier">UnaryFunctor</span> <span class="identifier">for_each</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardReadableRange</span> <span class="special">&amp;</span> <span class="identifier">r</span><span class="special">,</span> <span class="identifier">UnaryFunctor</span> <span class="identifier">func</span><span class="special">)</span>
 561 <span class="special">{</span>
 562     <span class="keyword">typedef</span> <span class="keyword">typename</span>
 563     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_const_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardReadableRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">const_iterator</span><span class="special">;</span>
 564
 565     <span class="keyword">for</span><span class="special">(</span><span class="identifier">const_iterator</span> <span class="identifier">i</span><span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">r</span><span class="special">),</span> <span class="identifier">iend</span><span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span> <span class="identifier">i</span><span class="special">!=</span><span class="identifier">iend</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
 566     <span class="special">{</span>
 567         <span class="identifier">func</span><span class="special">(*</span><span class="identifier">i</span><span class="special">);</span>
 568     <span class="special">}</span>
 569
 570     <span class="keyword">return</span> <span class="identifier">func</span><span class="special">;</span>
 571 <span class="special">}</span>
 572
 573 <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">ForwardReadableRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Predicate</span> <span class="special">&gt;</span>
 574 <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="identifier">ForwardReadableRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
 575     <span class="identifier">count_if</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardReadableRange</span> <span class="special">&amp;</span> <span class="identifier">r</span><span class="special">,</span> <span class="identifier">Predicate</span> <span class="identifier">pred</span><span class="special">)</span>
 576 <span class="special">{</span>
 577     <span class="keyword">typedef</span> <span class="keyword">typename</span>
 578     <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_const_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardReadableRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">const_iterator</span><span class="special">;</span>
 579
 580     <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="identifier">ForwardReadableRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">c</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
 581
 582     <span class="keyword">for</span><span class="special">(</span> <span class="identifier">const_iterator</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">r</span><span class="special">),</span> <span class="identifier">iend</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">r</span><span class="special">);</span> <span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">iend</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span> <span class="special">)</span>
 583     <span class="special">{</span>
 584         <span class="keyword">if</span><span class="special">(</span> <span class="identifier">pred</span><span class="special">(*</span><span class="identifier">i</span><span class="special">)</span> <span class="special">)</span> <span class="special">++</span><span class="identifier">c</span><span class="special">;</span>
 585     <span class="special">}</span>
 586
 587     <span class="keyword">return</span> <span class="identifier">c</span><span class="special">;</span>
 588 <span class="special">}</span>
 589 </pre>
 590 <p>
 591         </p>
 592 <p>
 593           We can use them with Boost.Bimap with the help of the <code class="computeroutput"><span class="identifier">range</span></code>
 594           function.
 595         </p>
 596 <p>
 597 </p>
 598 <pre class="programlisting"><span class="keyword">struct</span> <span class="identifier">pair_printer</span>
 599 <span class="special">{</span>
 600     <span class="identifier">pair_printer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span> <span class="identifier">o</span><span class="special">)</span> <span class="special">:</span> <span class="identifier">os</span><span class="special">(</span><span class="identifier">o</span><span class="special">)</span> <span class="special">{}</span>
 601     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Pair</span> <span class="special">&gt;</span>
 602     <span class="keyword">void</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">const</span> <span class="identifier">Pair</span> <span class="special">&amp;</span> <span class="identifier">p</span><span class="special">)</span>
 603     <span class="special">{</span>
 604         <span class="identifier">os</span> <span class="special">&lt;&lt;</span> <span class="string">"("</span> <span class="special">&lt;&lt;</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">","</span> <span class="special">&lt;&lt;</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="string">")"</span><span class="special">;</span>
 605     <span class="special">}</span>
 606     <span class="keyword">private</span><span class="special">:</span>
 607     <span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream</span> <span class="special">&amp;</span> <span class="identifier">os</span><span class="special">;</span>
 608 <span class="special">};</span>
 609
 610 <span class="keyword">struct</span> <span class="identifier">second_extractor</span>
 611 <span class="special">{</span>
 612     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Pair</span> <span class="special">&gt;</span>
 613     <span class="keyword">const</span> <span class="keyword">typename</span> <span class="identifier">Pair</span><span class="special">::</span><span class="identifier">second_type</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">const</span> <span class="identifier">Pair</span> <span class="special">&amp;</span> <span class="identifier">p</span><span class="special">)</span>
 614     <span class="special">{</span>
 615         <span class="keyword">return</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span><span class="special">;</span>
 616     <span class="special">}</span>
 617 <span class="special">};</span>
 618
 619 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 620 <span class="special">{</span>
 621     <span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span> <span class="keyword">double</span><span class="special">,</span> <span class="identifier">multiset_of</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">bm_type</span><span class="special">;</span>
 622
 623     <span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
 624     <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="number">2.5</span> <span class="special">,</span> <span class="number">1</span><span class="special">)</span> <span class="special">);</span>
 625     <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="number">3.1</span> <span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 626     <span class="comment">//...</span>
 627     <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="number">6.4</span> <span class="special">,</span> <span class="number">4</span><span class="special">)</span> <span class="special">);</span>
 628     <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="number">1.7</span> <span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 629
 630     <span class="comment">// Print all the elements of the left map view</span>
 631
 632     <span class="identifier">for_each</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">,</span> <span class="identifier">pair_printer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">)</span> <span class="special">);</span>
 633
 634     <span class="comment">// Print a range of elements of the right map view</span>
 635
 636     <span class="identifier">for_each</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span><span class="special">.</span><span class="identifier">range</span><span class="special">(</span> <span class="number">2</span> <span class="special">&lt;=</span> <span class="identifier">_key</span><span class="special">,</span> <span class="identifier">_key</span> <span class="special">&lt;</span> <span class="number">6</span> <span class="special">),</span> <span class="identifier">pair_printer</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">)</span> <span class="special">);</span>
 637
 638     <span class="comment">// Count the number of elements where the data is equal to 2 from a</span>
 639     <span class="comment">// range of elements of the left map view</span>
 640
 641     <span class="identifier">count_if</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">range</span><span class="special">(</span> <span class="number">2.3</span> <span class="special">&lt;</span> <span class="identifier">_key</span><span class="special">,</span> <span class="identifier">_key</span> <span class="special">&lt;</span> <span class="number">5.4</span> <span class="special">),</span>
 642               <span class="identifier">bind</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span> <span class="identifier">second_extractor</span><span class="special">(),</span> <span class="identifier">_1</span> <span class="special">)</span> <span class="special">==</span> <span class="number">2</span> <span class="special">);</span>
 643
 644     <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 645 <span class="special">}</span>
 646 </pre>
 647 <p>
 648         </p>
 649 <p>
 650           <a href="../../../../example/bimap_and_boost/range.cpp" target="_top">Go to source code</a>
 651         </p>
 652 </div>
 653 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_foreach">
 654 <div class="titlepage"><div><div><h4 class="title">
 655 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_foreach"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_foreach" title="Boost.Foreach">Boost.Foreach</a>
 656 </h4></div></div></div>
 657 <p>
 658           In C++, writing a loop that iterates over a sequence is tedious. We can
 659           either use iterators, which requires a considerable amount of boiler-plate,
 660           or we can use the std::for_each() algorithm and move our loop body into
 661           a predicate, which requires no less boiler-plate and forces us to move
 662           our logic far from where it will be used. In contrast, some other languages,
 663           like Perl, provide a dedicated "foreach" construct that automates
 664           this process. BOOST_FOREACH is just such a construct for C++. It iterates
 665           over sequences for us, freeing us from having to deal directly with iterators
 666           or write predicates.
 667         </p>
 668 <p>
 669           You can use BOOST_FOREACH macro with Boost.Bimap views. The generated code
 670           will be as efficient as a std::for_each iteration. Here are some examples:
 671         </p>
 672 <p>
 673 </p>
 674 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">list_of</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">bm_type</span><span class="special">;</span>
 675
 676 <span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
 677 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"1"</span><span class="special">,</span> <span class="number">1</span><span class="special">)</span> <span class="special">);</span>
 678 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"2"</span><span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 679 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"3"</span><span class="special">,</span> <span class="number">4</span><span class="special">)</span> <span class="special">);</span>
 680 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"4"</span><span class="special">,</span> <span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 681
 682 <span class="identifier">BOOST_FOREACH</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">left_reference</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span> <span class="special">)</span>
 683 <span class="special">{</span>
 684     <span class="special">++</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span><span class="special">;</span> <a class="co" name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_foreach.c0" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_foreach.c1"><img src="../../../../../../doc/src/images/callouts/1.png" alt="1" border="0"></a>
 685 <span class="special">}</span>
 686
 687 <span class="identifier">BOOST_FOREACH</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">right_const_reference</span> <span class="identifier">p</span><span class="special">,</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">right</span> <span class="special">)</span>
 688 <span class="special">{</span>
 689     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">"--&gt;"</span> <span class="special">&lt;&lt;</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 690 <span class="special">}</span>
 691 </pre>
 692 <p>
 693         </p>
 694 <div class="calloutlist"><table border="0" summary="Callout list"><tr>
 695 <td width="5%" valign="top" align="left"><p><a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_foreach.c1"></a><a href="#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_foreach.c0"><img src="../../../../../../doc/src/images/callouts/1.png" alt="1" border="0"></a> </p></td>
 696 <td valign="top" align="left"><p>
 697               We can modify the right element because we have use a mutable collection
 698               type in the right side.
 699             </p></td>
 700 </tr></table></div>
 701 <p>
 702           You can use it directly with ranges too:
 703         </p>
 704 <p>
 705 </p>
 706 <pre class="programlisting"><span class="identifier">BOOST_FOREACH</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">left_reference</span> <span class="identifier">p</span><span class="special">,</span>
 707              <span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">range</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">"1"</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="identifier">_key</span><span class="special">,</span> <span class="identifier">_key</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">"3"</span><span class="special">)</span> <span class="special">)</span> <span class="special">))</span>
 708 <span class="special">{</span>
 709     <span class="special">++</span><span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span><span class="special">;</span>
 710 <span class="special">}</span>
 711
 712 <span class="identifier">BOOST_FOREACH</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">left_const_reference</span> <span class="identifier">p</span><span class="special">,</span>
 713              <span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">left</span><span class="special">.</span><span class="identifier">range</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">"1"</span><span class="special">)</span> <span class="special">&lt;=</span> <span class="identifier">_key</span><span class="special">,</span> <span class="identifier">_key</span> <span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">"3"</span><span class="special">)</span> <span class="special">)</span> <span class="special">))</span>
 714 <span class="special">{</span>
 715     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">"--&gt;"</span> <span class="special">&lt;&lt;</span> <span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 716 <span class="special">}</span>
 717 </pre>
 718 <p>
 719         </p>
 720 <p>
 721           <a href="../../../../example/bimap_and_boost/foreach.cpp" target="_top">Go to source code</a>
 722         </p>
 723 </div>
 724 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_typeof">
 725 <div class="titlepage"><div><div><h4 class="title">
 726 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_typeof"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_typeof" title="Boost.Typeof">Boost.Typeof</a>
 727 </h4></div></div></div>
 728 <p>
 729           Once C++0x is out we are going to be able to write code like:
 730         </p>
 731 <pre class="programlisting"><span class="keyword">auto</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;().</span><span class="identifier">find</span><span class="special">(</span><span class="string">"john"</span><span class="special">);</span>
 732 </pre>
 733 <p>
 734           instead of the more verbose
 735         </p>
 736 <pre class="programlisting"><span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">map_by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;().</span><span class="identifier">find</span><span class="special">(</span><span class="string">"john"</span><span class="special">);</span>
 737 </pre>
 738 <p>
 739           Boost.Typeof defines a macro BOOST_AUTO that can be used as a library solution
 740           to the auto keyword while we wait for the next standard.
 741         </p>
 742 <p>
 743           If we have
 744         </p>
 745 <p>
 746 </p>
 747 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">tagged</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span><span class="identifier">name</span><span class="special">&gt;,</span> <span class="identifier">tagged</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">number</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">bm_type</span><span class="special">;</span>
 748 <span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
 749 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"one"</span>  <span class="special">,</span><span class="number">1</span><span class="special">)</span> <span class="special">);</span>
 750 <span class="identifier">bm</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">(</span><span class="string">"two"</span>  <span class="special">,</span><span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 751 </pre>
 752 <p>
 753         </p>
 754 <p>
 755           The following code snippet
 756         </p>
 757 <p>
 758 </p>
 759 <pre class="programlisting"><span class="keyword">for</span><span class="special">(</span> <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">map_by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;().</span><span class="identifier">begin</span><span class="special">();</span>
 760      <span class="identifier">iter</span><span class="special">!=</span><span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">iter</span><span class="special">)</span>
 761 <span class="special">{</span>
 762     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">iter</span><span class="special">-&gt;</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">" --&gt; "</span> <span class="special">&lt;&lt;</span> <span class="identifier">iter</span><span class="special">-&gt;</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 763 <span class="special">}</span>
 764
 765 <span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">map_by</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">iter</span> <span class="special">=</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&gt;().</span><span class="identifier">find</span><span class="special">(</span><span class="number">2</span><span class="special">);</span>
 766 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"2: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">iter</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;();</span>
 767 </pre>
 768 <p>
 769         </p>
 770 <p>
 771           can be rewrited as
 772         </p>
 773 <p>
 774 </p>
 775 <pre class="programlisting"><span class="keyword">for</span><span class="special">(</span> <span class="identifier">BOOST_AUTO</span><span class="special">(</span><span class="identifier">iter</span><span class="special">,</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;().</span><span class="identifier">begin</span><span class="special">());</span> <span class="identifier">iter</span><span class="special">!=</span><span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">();</span> <span class="special">++</span><span class="identifier">iter</span><span class="special">)</span>
 776 <span class="special">{</span>
 777     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">iter</span><span class="special">-&gt;</span><span class="identifier">first</span> <span class="special">&lt;&lt;</span> <span class="string">" --&gt; "</span> <span class="special">&lt;&lt;</span> <span class="identifier">iter</span><span class="special">-&gt;</span><span class="identifier">second</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
 778 <span class="special">}</span>
 779
 780 <span class="identifier">BOOST_AUTO</span><span class="special">(</span> <span class="identifier">iter</span><span class="special">,</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">by</span><span class="special">&lt;</span><span class="identifier">number</span><span class="special">&gt;().</span><span class="identifier">find</span><span class="special">(</span><span class="number">2</span><span class="special">)</span> <span class="special">);</span>
 781 <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"2: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">iter</span><span class="special">-&gt;</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">name</span><span class="special">&gt;();</span>
 782 </pre>
 783 <p>
 784         </p>
 785 <p>
 786           <a href="../../../../example/bimap_and_boost/typeof.cpp" target="_top">Go to source code</a>
 787         </p>
 788 </div>
 789 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_xpressive">
 790 <div class="titlepage"><div><div><h4 class="title">
 791 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_xpressive"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_xpressive" title="Boost.Xpressive">Boost.Xpressive</a>
 792 </h4></div></div></div>
 793 <p>
 794           Using Boost.Xpressive we can parse a file and insert the relations in a
 795           bimap in the same step. It is just amazing the power of four lines of code.
 796           Here is an example (it is just beatifull)
 797         </p>
 798 <p>
 799 </p>
 800 <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="keyword">int</span> <span class="special">&gt;</span> <span class="identifier">bm_type</span><span class="special">;</span>
 801 <span class="identifier">bm_type</span> <span class="identifier">bm</span><span class="special">;</span>
 802
 803 <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">rel_str</span><span class="special">(</span><span class="string">"one &lt;--&gt; 1     two &lt;--&gt; 2      three &lt;--&gt; 3"</span><span class="special">);</span>
 804
 805 <span class="identifier">sregex</span> <span class="identifier">rel</span> <span class="special">=</span> <span class="special">(</span> <span class="special">(</span><span class="identifier">s1</span><span class="special">=</span> <span class="special">+</span><span class="identifier">_w</span><span class="special">)</span> <span class="special">&gt;&gt;</span> <span class="string">" &lt;--&gt; "</span> <span class="special">&gt;&gt;</span> <span class="special">(</span><span class="identifier">s2</span><span class="special">=</span> <span class="special">+</span><span class="identifier">_d</span><span class="special">)</span> <span class="special">)</span>
 806 <span class="special">[</span>
 807     <span class="identifier">xp</span><span class="special">::</span><span class="identifier">ref</span><span class="special">(</span><span class="identifier">bm</span><span class="special">)-&gt;*</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">xp</span><span class="special">::</span><span class="identifier">construct</span><span class="special">&lt;</span><span class="identifier">bm_type</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;(</span><span class="identifier">s1</span><span class="special">,</span> <span class="identifier">as</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">s2</span><span class="special">))</span> <span class="special">)</span>
 808 <span class="special">];</span>
 809
 810 <span class="identifier">sregex</span> <span class="identifier">relations</span> <span class="special">=</span> <span class="identifier">rel</span> <span class="special">&gt;&gt;</span> <span class="special">*(+</span><span class="identifier">_s</span> <span class="special">&gt;&gt;</span> <span class="identifier">rel</span><span class="special">);</span>
 811
 812 <span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">rel_str</span><span class="special">,</span> <span class="identifier">relations</span><span class="special">);</span>
 813
 814 <span class="identifier">assert</span><span class="special">(</span> <span class="identifier">bm</span><span class="special">.</span><span class="identifier">size</span><span class="special">()</span> <span class="special">==</span> <span class="number">3</span> <span class="special">);</span>
 815 </pre>
 816 <p>
 817         </p>
 818 <p>
 819           <a href="../../../../example/bimap_and_boost/xpressive.cpp" target="_top">Go to source code</a>
 820         </p>
 821 </div>
 822 <div class="section boost_bimap_bimap_and_boost_boost_libraries_that_work_well_with_boost_bimap_boost_property_map">
 823 <div class="titlepage"><div><div><h4 class="title">
 824 <a name="boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_property_map"></a><a class="link" href="boost_libraries_that_work_well_with_boost_bimap.html#boost_bimap.bimap_and_boost.boost_libraries_that_work_well_with_boost_bimap.boost_property_map" title="Boost.Property_map">Boost.Property_map</a>
 825 </h4></div></div></div>
 826 <p>
 827           The Boost Property Map Library consists mainly of interface specifications
 828           in the form of concepts (similar to the iterator concepts in the STL).
 829           These interface specifications are intended for use by implementers of
 830           generic libraries in communicating requirements on template parameters
 831           to their users. In particular, the Boost Property Map concepts define a
 832           general purpose interface for mapping key objects to corresponding value
 833           objects, thereby hiding the details of how the mapping is implemented from
 834           algorithms.
 835         </p>
 836 <p>
 837           The need for the property map interface came from the Boost Graph Library
 838           (BGL), which contains many examples of algorithms that use the property
 839           map concepts to specify their interface. For an example, note the ColorMap
 840           template parameter of the breadth_first_search. In addition, the BGL contains
 841           many examples of concrete types that implement the property map interface.
 842           The adjacency_list class implements property maps for accessing objects
 843           (properties) that are attached to vertices and edges of the graph.
 844         </p>
 845 <p>
 846           The counterparts of two of the views of Boost.Bimap map, the <code class="computeroutput"><span class="identifier">set</span></code> and <code class="computeroutput"><span class="identifier">unordered_set</span></code>,
 847           are read-write property maps. In order to use these, you need to include
 848           one of the following headers:
 849         </p>
 850 <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">bimap</span><span class="special">/</span><span class="identifier">property_map</span><span class="special">/</span><span class="identifier">set_support</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 851 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">bimap</span><span class="special">/</span><span class="identifier">property_map</span><span class="special">/</span><span class="identifier">unordered_set_support</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 852 </pre>
 853 <p>
 854           The following is adapted from the example in the Boost.PropertyMap documentation.
 855         </p>
 856 <p>
 857           <a href="../../../../example/bimap_and_boost/property_map.cpp" target="_top">Go to source
 858           code</a>
 859         </p>
 860 <p>
 861 </p>
 862 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">AddressMap</span><span class="special">&gt;</span>
 863 <span class="keyword">void</span> <span class="identifier">foo</span><span class="special">(</span><span class="identifier">AddressMap</span> <span class="special">&amp;</span> <span class="identifier">address_map</span><span class="special">)</span>
 864 <span class="special">{</span>
 865     <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">property_traits</span><span class="special">&lt;</span><span class="identifier">AddressMap</span><span class="special">&gt;::</span><span class="identifier">value_type</span> <span class="identifier">value_type</span><span class="special">;</span>
 866     <span class="keyword">typedef</span> <span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">property_traits</span><span class="special">&lt;</span><span class="identifier">AddressMap</span><span class="special">&gt;::</span><span class="identifier">key_type</span> <span class="identifier">key_type</span><span class="special">;</span>
 867
 868     <span class="identifier">value_type</span> <span class="identifier">address</span><span class="special">;</span>
 869     <span class="identifier">key_type</span> <span class="identifier">fred</span> <span class="special">=</span> <span class="string">"Fred"</span><span class="special">;</span>
 870     <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">get</span><span class="special">(</span><span class="identifier">address_map</span><span class="special">,</span> <span class="identifier">fred</span><span class="special">);</span>
 871 <span class="special">}</span>
 872
 873 <span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
 874 <span class="special">{</span>
 875     <span class="keyword">typedef</span> <span class="identifier">bimap</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">,</span> <span class="identifier">multiset_of</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">Name2Address</span><span class="special">;</span>
 876     <span class="keyword">typedef</span> <span class="identifier">Name2Address</span><span class="special">::</span><span class="identifier">value_type</span> <span class="identifier">location</span><span class="special">;</span>
 877
 878     <span class="identifier">Name2Address</span> <span class="identifier">name2address</span><span class="special">;</span>
 879     <span class="identifier">name2address</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">location</span><span class="special">(</span><span class="string">"Fred"</span><span class="special">,</span> <span class="string">"710 West 13th Street"</span><span class="special">)</span> <span class="special">);</span>
 880     <span class="identifier">name2address</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span> <span class="identifier">location</span><span class="special">(</span> <span class="string">"Joe"</span><span class="special">,</span> <span class="string">"710 West 13th Street"</span><span class="special">)</span> <span class="special">);</span>
 881
 882     <span class="identifier">foo</span><span class="special">(</span> <span class="identifier">name2address</span><span class="special">.</span><span class="identifier">left</span> <span class="special">);</span>
 883
 884     <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
 885 <span class="special">}</span>
 886 </pre>
 887 <p>
 888         </p>
 889 </div>
 890 </div>
 891 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 892 <td align="left"></td>
 893 <td align="right"><div class="copyright-footer">Copyright &#169; 2006-2012 Matias Capeletto<p>
 894         Distributed under the Boost Software License, Version 1.0. (See accompanying
 895         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>)
 896       </p>
 897 </div></td>
 898 </tr></table>
 899 <hr>
 900 <div class="spirit-nav">
 901 <a accesskey="p" href="../bimap_and_boost.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../bimap_and_boost.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="dependencies.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 902 </div>
 903 </body>
 904 </html>