ceph/src/boost/libs/flyweight/doc/reference/factories.html

   1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
   2
   3 <html>
   4 <head>
   5 <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
   6 <title>Boost.Flyweight Documentation - Factories reference</title>
   7 <link rel="stylesheet" href="../style.css" type="text/css">
   8 <link rel="start" href="../index.html">
   9 <link rel="prev" href="tags.html">
  10 <link rel="up" href="index.html">
  11 <link rel="next" href="holders.html">
  12 </head>
  13
  14 <body>
  15 <h1><img src="../../../../boost.png" alt="Boost logo" align=
  16 "middle" width="277" height="86">Boost.Flyweight
  17 Factories reference</h1>
  18
  19 <div class="prev_link"><a href="tags.html"><img src="../prev.gif" alt="tags" border="0"><br>
  20 Tags
  21 </a></div>
  22 <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.Flyweight reference" border="0"><br>
  23 Boost.Flyweight reference
  24 </a></div>
  25 <div class="next_link"><a href="holders.html"><img src="../next.gif" alt="holders" border="0"><br>
  26 Holders
  27 </a></div><br clear="all" style="clear: all;">
  28
  29 <hr>
  30
  31 <h2>Contents</h2>
  32
  33 <ul>
  34   <li><a href="#factory">Factories and factory specifiers</a></li>
  35   <li><a href="#factory_tag_synopsis">Header
  36     <code>"boost/flyweight/factory_tag.hpp"</code> synopsis</a>
  37     <ul>
  38       <li><a href="#is_factory">Class template <code>is_factory</code></a></li>
  39       <li><a href="#factory_construct">Class template <code>factory</code></a></li>
  40     </ul>
  41   </li>
  42   <li><a href="#hashed_factory_fwd_synopsis">Header
  43     <code>"boost/flyweight/hashed_factory_fwd.hpp"</code> synopsis</a>
  44   </li>
  45   <li><a href="#hashed_factory_synopsis">Header
  46     <code>"boost/flyweight/hashed_factory.hpp"</code> synopsis</a>
  47     <ul>
  48       <li><a href="#hashed_factory_class">Class template <code>hashed_factory_class</code></a></li>
  49       <li><a href="#hashed_factory">Class template <code>hashed_factory</code></a></li>
  50     </ul>
  51   </li>
  52   <li><a href="#set_factory_fwd_synopsis">Header
  53     <code>"boost/flyweight/set_factory_fwd.hpp"</code> synopsis</a>
  54   </li>
  55   <li><a href="#set_factory_synopsis">Header
  56     <code>"boost/flyweight/set_factory.hpp"</code> synopsis</a>
  57     <ul>
  58       <li><a href="#set_factory_class">Class template <code>set_factory_class</code></a></li>
  59       <li><a href="#set_factory">Class template <code>set_factory</code></a></li>
  60     </ul>
  61   </li>
  62   <li><a href="#assoc_container_factory_fwd_synopsis">Header
  63     <code>"boost/flyweight/assoc_container_factory_fwd.hpp"</code> synopsis</a>
  64   </li>
  65   <li><a href="#assoc_container_factory_synopsis">Header
  66     <code>"boost/flyweight/assoc_container_factory.hpp"</code> synopsis</a>
  67     <ul>
  68       <li><a href="#assoc_container_factory_class">Class template <code>assoc_container_factory_class</code></a></li>
  69       <li><a href="#assoc_container_factory">Class template <code>assoc_container_factory</code></a></li>
  70     </ul>
  71   </li>
  72 </ul>
  73
  74 <h2><a name="factory">Factories and factory specifiers</a></h2>
  75
  76 <p>
  77 Given a type <code>Key</code> and an
  78 <a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>
  79 type <code>Entry</code> implicitly convertible to <code>const Key&amp;</code>, a
  80 <i>factory of <code>Entry</code> elements</i> (implicitly associated to
  81 <code>Key</code>) is a
  82 <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html"><code>Default
  83 Constructible</code></a> entity able to store and retrieve immutable elements of
  84 type <code>Entry</code>. A factory is governed by an associated equivalence
  85 relation defined on <code>Key</code> so that no two
  86 <code>Entry</code> objects convertible to equivalent <code>Key</code>s
  87 can be stored simultaneously in the factory. Different factory types can
  88 use different equivalence relations.
  89 </p>
  90
  91 <p>
  92 In the following table, <code>Factory</code> is a factory of elements
  93 of type <code>Entry</code>, <code>f</code> denotes an object of type <code>Factory</code>,
  94 <code>x</code> is an object of type <code>Entry</code> and <code>h</code> is a
  95 value of <code>Factory::handle_type</code>.
  96 </p>
  97
  98 <p align="center">
  99 <table cellspacing="0">
 100   <caption><b>Factory requirements.</b></caption>
 101 <tr>
 102   <th align="center">expression</th>
 103   <th align="center">return type</th>
 104   <th align="center">assertion/note<br>pre/post-condition</th>
 105 </tr>
 106 <tr>
 107   <td><code>Factory::handle_type</code></td>
 108   <td>handle to elements of type <code>T</code><br>
 109     stored in the factory
 110   </td>
 111   <td><code>handle_type</code> is
 112     <a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>
 113     and its copy and<br>
 114     assignment operations never throw an exception.
 115   </td>
 116 </tr>
 117 <tr class="odd_tr">
 118   <td><code>f.insert(x);</code></td>
 119   <td><code>handle_type</code></td>
 120   <td>Inserts a copy of <code>x</code> if there is no equivalent entry in <code>f</code>;<br>
 121     returns a handle to the inserted or equivalent element.
 122   </td>
 123 </tr>
 124 <tr>
 125   <td><code>f.erase(h);</code></td>
 126   <td><code>void</code></td>
 127   <td>Erases the element associated to <code>h</code>.<br>
 128    This operation does not throw.
 129   </td>
 130 </tr>
 131 <tr class="odd_tr">
 132   <td><code>f.entry(h);</code></td>
 133   <td><code>const Entry&amp;</code></td>
 134   <td>Returns a reference to the element associated to <code>h</code>.<br>
 135     This operation does not throw.
 136   </td>
 137 </tr>
 138 </table>
 139 </p>
 140
 141 <p>
 142 Additionally to the basic thread safety guarantee which is implicitly assumed
 143 for most classes including the majority of components of the
 144 C++ standard library, it is required that the member function <code>entry</code>
 145 can be invoked simultaneously from different threads, even in the presence
 146 of concurrent accesses to <code>insert</code> and <code>erase</code> (as long
 147 as the entry returned by <code>entry</code> is not the one which is being
 148 erased).
 149 </p>
 150
 151 <p>
 152 A type <code>S</code> is said to be a <i>factory specifier</i> if:
 153 <ol>
 154   <li>One of the following conditions is satisfied:
 155     <ol type="a">
 156       <li><a href="#is_factory"><code>is_factory&lt;S&gt;::type</code></a> is
 157       <a href="../../../mpl/doc/refmanual/bool.html"><code>boost::mpl::true_</code></a>,</li>
 158       <li><code>S</code> is of the form <a href="#factory_construct"><code>factory&lt;S'&gt;</code></a>.</li>
 159     </ol>
 160   </li>
 161   <li><code>S</code>, or <code>S'</code> if (b) applies, is an
 162     <a href="../../../mpl/doc/refmanual/lambda-expression.html"><code>MPL Lambda
 163     Expression</code></a> such that invoking it with types (<code>Entry</code>,
 164     <code>Key</code>) resolves to a factory type of <code>Entry</code> elements
 165     (implicitly associated to <code>Key</code>).
 166   </li>
 167 </ol>
 168 </p>
 169
 170 <h2><a name="factory_tag_synopsis">Header
 171 <a href="../../../../boost/flyweight/factory_tag.hpp"><code>"boost/flyweight/factory_tag.hpp"</code></a> synopsis</a></h2>
 172
 173 <blockquote><pre>
 174 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
 175
 176 <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
 177
 178 <span class=keyword>struct</span> <span class=identifier>factory_marker</span><span class=special>;</span>
 179
 180 <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>
 181 <span class=keyword>struct</span> <span class=identifier>is_factory</span><span class=special>;</span>
 182
 183 <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>
 184 <span class=keyword>struct</span> <span class=identifier>factory</span><span class=special>;</span>
 185
 186 <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
 187
 188 <span class=special>}</span> <span class=comment>// namespace boost</span>
 189 </pre></blockquote>
 190
 191 <h3><a name="is_factory">Class template <code>is_factory</code></a></h3>
 192
 193 <p>
 194 Unless specialized by the user, <code>is_factory&lt;T&gt;::type</code> is
 195 <a href="../../../mpl/doc/refmanual/bool.html"><code>boost::mpl::true_</code></a>
 196 if <code>T</code> is derived from <code>factory_marker</code>, and it is
 197 <a href="../../../mpl/doc/refmanual/bool.html"><code>boost::mpl::false_</code></a>
 198 otherwise.
 199 </p>
 200
 201 <h3><a name="factory_construct">Class template <code>factory</code></a></h3>
 202
 203 <p>
 204 <code>factory&lt;T&gt;</code> is a syntactic construct meant to indicate
 205 that <code>T</code> is a factory specifier without resorting to the
 206 mechanisms provided by the <code>is_factory</code> class template.
 207 </p>
 208
 209 <h2><a name="hashed_factory_fwd_synopsis">Header
 210 <a href="../../../../boost/flyweight/hashed_factory_fwd.hpp"><code>"boost/flyweight/hashed_factory_fwd.hpp"</code></a> synopsis</a></h2>
 211
 212 <blockquote><pre>
 213 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
 214
 215 <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
 216
 217 <span class=keyword>template</span><span class=special>&lt;</span>
 218   <span class=keyword>typename</span> <span class=identifier>Entry</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Key</span><span class=special>,</span>
 219   <span class=keyword>typename</span> <span class=identifier>Hash</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
 220   <span class=keyword>typename</span> <span class=identifier>Pred</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
 221   <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><b>implementation defined</b>
 222 <span class=special>&gt;</span>
 223 <span class=keyword>class</span> <span class=identifier>hashed_factory_class</span><span class=special>;</span>
 224
 225 <span class=keyword>template</span><span class=special>&lt;</span>
 226   <span class=keyword>typename</span> <span class=identifier>Hash</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
 227   <span class=keyword>typename</span> <span class=identifier>Pred</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
 228   <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><b>implementation defined</b>
 229 <span class=special>&gt;</span>
 230 <span class=keyword>struct</span> <span class=identifier>hashed_factory</span><span class=special>;</span>
 231
 232 <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
 233
 234 <span class=special>}</span> <span class=comment>// namespace boost</span>
 235 </pre></blockquote>
 236
 237 <p>
 238 <code>hashed_factory_fwd.hpp</code> forward declares the class templates
 239 <a href="#hashed_factory_class"><code>hashed_factory_class</code></a>
 240 and <a href="#hashed_factory"><code>hashed_factory</code></a>.
 241 </p>
 242
 243 <h2><a name="hashed_factory_synopsis">Header
 244 <a href="../../../../boost/flyweight/hashed_factory.hpp"><code>"boost/flyweight/hashed_factory.hpp"</code></a> synopsis</a></h2>
 245
 246 <h3><a name="hashed_factory_class">Class template <code>hashed_factory_class</code></a></h3>
 247
 248 <p>
 249 <code>hashed_factory_class</code> is a <a href="#factory"><code>Factory</code></a>
 250 implemented with a hashed container.
 251 </p>
 252
 253 <blockquote><pre>
 254 <span class=keyword>template</span><span class=special>&lt;</span>
 255   <span class=keyword>typename</span> <span class=identifier>Entry</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Key</span><span class=special>,</span>
 256   <span class=keyword>typename</span> <span class=identifier>Hash</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Pred</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 257 <span class=special>&gt;</span>
 258 <span class=keyword>class</span> <span class=identifier>hashed_factory_class</span>
 259 <span class=special>{</span>
 260 <span class=keyword>public</span><span class=special>:</span>
 261   <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>handle_type</span><span class=special>;</span>
 262
 263   <span class=identifier>handle_type</span>  <span class=identifier>insert</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>Entry</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 264   <span class=keyword>void</span>         <span class=identifier>erase</span><span class=special>(</span><span class=identifier>handle_type</span> <span class=identifier>h</span><span class=special>);</span>
 265   <span class=keyword>const</span> <span class=identifier>Entry</span><span class=special>&amp;</span> <span class=identifier>entry</span><span class=special>(</span><span class=identifier>handle_type</span> <span class=identifier>h</span><span class=special>);</span>
 266 <span class=special>};</span>
 267 </pre></blockquote>
 268
 269 <p>
 270 <code>Hash</code> is a
 271 <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html"><code>Default
 272 Constructible</code></a>
 273 <a href="http://www.sgi.com/tech/stl/UnaryFunction.html"><code>Unary Function</code></a>
 274 taking a single argument of type <code>Key</code> and returning a
 275 value of type <code>std::size_t</code> in the range
 276 <code>[0, std::numeric_limits&lt;std::size_t&gt;::max())</code>.
 277 <code>Pred</code> is a
 278 <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html"><code>Default
 279 Constructible</code></a>
 280 <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">
 281 <code>Binary Predicate</code></a> inducing an equivalence relation
 282 on elements of <code>Key</code>. It is required that
 283 a <code>Hash</code> object return the same value for objects
 284 equivalent under <code>Pred</code>.
 285 The equivalence relation on <code>Key</code> associated to the factory is
 286 that induced by <code>Pred</code>.
 287 The default arguments for <code>Hash</code> and <code>Pred</code> are
 288 <a href="../../../functional/hash/index.html"><code>boost::hash&lt;Key&gt;</code></a>
 289 and <code>std::equal_to&lt;Key&gt;</code>, respectively.
 290 <code>Allocator</code> must be an allocator of <code>Entry</code> objects
 291 satisfying the associated C++ requirements at <b>[lib.allocator.requirements]</b>.
 292 The default argument is <code>std::allocator&lt;Entry&gt;</code>. The internal
 293 hashed container upon which <code>hashed_factory_class</code> is based is
 294 constructed with default initialized objects of type <code>Hash</code>,
 295 <code>Pred</code> and <code>Allocator</code>.
 296 </p>
 297
 298 <h3><a name="hashed_factory">Class template <code>hashed_factory</code></a></h3>
 299
 300 <p>
 301 <a href="#factory"><code>Factory Specifier</code></a> for <a href="#hashed_factory_class"><code>hashed_factory_class</code></a>.
 302 </p>
 303
 304 <blockquote><pre>
 305 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Hash</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Pred</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>&gt;</span>
 306 <span class=keyword>struct</span> <span class=identifier>hashed_factory</span><span class=special>;</span>
 307 </pre></blockquote>
 308
 309 <p>
 310 <code>hashed_factory&lt;Hash,Pred,Allocator&gt;</code> is an
 311 <a href="../../../mpl/doc/refmanual/metafunction-class.html"><code>MPL Metafunction
 312 Class</code></a> such that the type
 313 </p>
 314
 315 <blockquote><pre>
 316 <span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>apply</span><span class=special>&lt;</span>
 317   <span class=identifier>hashed_factory</span><span class=special>&lt;</span><span class=identifier>Hash</span><span class=special>,</span><span class=identifier>Pred</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span>
 318   <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span>
 319 <span class=special>&gt;::</span><span class=identifier>type</span>
 320 </pre></blockquote>
 321
 322 <p>
 323 is the same as
 324 </p>
 325
 326 <blockquote><pre>
 327 <span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>apply</span><span class=special>&lt;</span>
 328   <span class=identifier>hashed_factory_class</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>_1</span><span class=special>,</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>_2</span><span class=special>,</span><span class=identifier>Hash</span><span class=special>,</span><span class=identifier>Pred</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span>
 329   <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span>
 330 <span class=special>&gt;::</span><span class=identifier>type</span>
 331 </pre></blockquote>
 332
 333 <p>
 334 This implies that <code>Hash</code>, <code>Pred</code> and <code>Allocator</code>
 335 can be
 336 <a href="../../../mpl/doc/refmanual/placeholder-expression.html"><code>MPL
 337 Placeholder Expressions</code></a> resolving to the actual types used by
 338 <code>hashed_factory_class</code>.
 339 </p>
 340
 341 <h2><a name="set_factory_fwd_synopsis">Header
 342 <a href="../../../../boost/flyweight/set_factory_fwd.hpp"><code>"boost/flyweight/set_factory_fwd.hpp"</code></a> synopsis</a></h2>
 343
 344 <blockquote><pre>
 345 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
 346
 347 <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
 348
 349 <span class=keyword>template</span><span class=special>&lt;</span>
 350   <span class=keyword>typename</span> <span class=identifier>Entry</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Key</span><span class=special>,</span>
 351   <span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
 352   <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><b>implementation defined</b>
 353 <span class=special>&gt;</span>
 354 <span class=keyword>class</span> <span class=identifier>set_factory_class</span><span class=special>;</span>
 355
 356 <span class=keyword>template</span><span class=special>&lt;</span>
 357   <span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
 358   <span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>=</span><b>implementation defined</b>
 359 <span class=special>&gt;</span>
 360 <span class=keyword>struct</span> <span class=identifier>set_factory</span><span class=special>;</span>
 361
 362 <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
 363
 364 <span class=special>}</span> <span class=comment>// namespace boost</span>
 365 </pre></blockquote>
 366
 367 <p>
 368 <code>set_factory_fwd.hpp</code> forward declares the class templates
 369 <a href="#set_factory_class"><code>set_factory_class</code></a>
 370 and <a href="#set_factory"><code>set_factory</code></a>.
 371 </p>
 372
 373 <h2><a name="set_factory_synopsis">Header
 374 <a href="../../../../boost/flyweight/set_factory.hpp"><code>"boost/flyweight/set_factory.hpp"</code></a> synopsis</a></h2>
 375
 376 <h3><a name="set_factory_class">Class template <code>set_factory_class</code></a></h3>
 377
 378 <p>
 379 <code>set_factory_class</code> is a <a href="#factory"><code>Factory</code></a>
 380 implemented on top of an orderded associative container.
 381 </p>
 382
 383 <blockquote><pre>
 384 <span class=keyword>template</span><span class=special>&lt;</span>
 385   <span class=keyword>typename</span> <span class=identifier>Entry</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Key</span><span class=special>,</span>
 386   <span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span>
 387 <span class=special>&gt;</span>
 388 <span class=keyword>class</span> <span class=identifier>set_factory_class</span>
 389 <span class=special>{</span>
 390 <span class=keyword>public</span><span class=special>:</span>
 391   <span class=keyword>typedef</span> <b>implementation defined</b> <span class=identifier>handle_type</span><span class=special>;</span>
 392
 393   <span class=identifier>handle_type</span>  <span class=identifier>insert</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>Entry</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 394   <span class=keyword>void</span>         <span class=identifier>erase</span><span class=special>(</span><span class=identifier>handle_type</span> <span class=identifier>h</span><span class=special>);</span>
 395   <span class=keyword>const</span> <span class=identifier>Entry</span><span class=special>&amp;</span> <span class=identifier>entry</span><span class=special>(</span><span class=identifier>handle_type</span> <span class=identifier>h</span><span class=special>);</span>
 396 <span class=special>};</span>
 397 </pre></blockquote>
 398
 399 <p>
 400 <code>Compare</code> is a
 401 <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html"><code>Default
 402 Constructible</code></a>
 403 <a href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html">
 404 <code>Strict Weak Ordering</code></a> on <code>Key</code>. Two <code>Key</code>s
 405 <code>x</code> and <code>y</code> are considered equivalent if
 406 <code>!c(x,y)&amp;&amp;!c(y,x)</code> for <code>c</code> of type <code>Compare</code>.
 407 The default argument of <code>Compare</code> is <code>std::less&lt;Key&gt;</code>
 408 <code>Allocator</code> must be an allocator of <code>Entry</code> objects
 409 satisfying the associated C++ requirements at <b>[lib.allocator.requirements]</b>.
 410 The default argument is <code>std::allocator&lt;Entry&gt;</code>. The internal
 411 container upon which <code>set_factory_class</code> is based is
 412 constructed with default initialized objects of type <code>Compare</code>
 413 and <code>Allocator</code>.
 414 </p>
 415
 416 <h3><a name="set_factory">Class template <code>set_factory</code></a></h3>
 417
 418 <p>
 419 <a href="#factory"><code>Factory Specifier</code></a> for <a href="#set_factory_class"><code>set_factory_class</code></a>.
 420 </p>
 421
 422 <blockquote><pre>
 423 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Compare</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Allocator</span><span class=special>&gt;</span>
 424 <span class=keyword>struct</span> <span class=identifier>set_factory</span><span class=special>;</span>
 425 </pre></blockquote>
 426
 427 <p>
 428 <code>set_factory&lt;Compare,Allocator&gt;</code> is an
 429 <a href="../../../mpl/doc/refmanual/metafunction-class.html"><code>MPL Metafunction
 430 Class</code></a> such that the type
 431 </p>
 432
 433 <blockquote><pre>
 434 <span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>apply</span><span class=special>&lt;</span>
 435   <span class=identifier>set_factory</span><span class=special>&lt;</span><span class=identifier>Compare</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span>
 436   <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span>
 437 <span class=special>&gt;::</span><span class=identifier>type</span>
 438 </pre></blockquote>
 439
 440 <p>
 441 is the same as
 442 </p>
 443
 444 <blockquote><pre>
 445 <span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>apply</span><span class=special>&lt;</span>
 446   <span class=identifier>set_factory_class</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>_1</span><span class=special>,</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>mpl</span><span class=special>::</span><span class=identifier>_2</span><span class=special>,</span><span class=identifier>Compare</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>&gt;,</span>
 447   <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span>
 448 <span class=special>&gt;::</span><span class=identifier>type</span>
 449 </pre></blockquote>
 450
 451 <p>
 452 This implies that <code>Compare</code> and <code>Allocator</code>
 453 can be
 454 <a href="../../../mpl/doc/refmanual/placeholder-expression.html"><code>MPL
 455 Placeholder Expressions</code></a> resolving to the actual types used by
 456 <code>set_factory_class</code>.
 457 </p>
 458
 459 <h2><a name="assoc_container_factory_fwd_synopsis">Header
 460 <a href="../../../../boost/flyweight/assoc_container_factory_fwd.hpp"><code>"boost/flyweight/assoc_container_factory_fwd.hpp"</code></a> synopsis</a></h2>
 461
 462 <blockquote><pre>
 463 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
 464
 465 <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
 466
 467 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Container</span><span class=special>&gt;</span>
 468 <span class=keyword>class</span> <span class=identifier>assoc_container_factory_class</span><span class=special>;</span>
 469
 470 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ContainerSpecifier</span><span class=special>&gt;</span>
 471 <span class=keyword>struct</span> <span class=identifier>assoc_container_factory</span><span class=special>;</span>
 472
 473 <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
 474
 475 <span class=special>}</span> <span class=comment>// namespace boost</span>
 476 </pre></blockquote>
 477
 478 <p>
 479 <code>assoc_container_factory_fwd.hpp</code> forward declares the class templates
 480 <a href="#assoc_container_factory_class"><code>assoc_container_factory_class</code></a>
 481 and <a href="#assoc_container_factory"><code>assoc_container_factory</code></a>.
 482 </p>
 483
 484 <h2><a name="assoc_container_factory_synopsis">Header
 485 <a href="../../../../boost/flyweight/assoc_container_factory.hpp"><code>"boost/flyweight/assoc_container_factory.hpp"</code></a> synopsis</a></h2>
 486
 487 <h3><a name="assoc_container_factory_class">Class template <code>assoc_container_factory_class</code></a></h3>
 488
 489 <p>
 490 <code>assoc_container_factory_class</code> wraps a suitable associative container
 491 to provide a <a href="#factory"><code>Factory</code></a> interface.
 492 </p>
 493
 494 <blockquote><pre>
 495 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>Container</span><span class=special>&gt;</span>
 496 <span class=keyword>class</span> <span class=identifier>assoc_container_factory_class</span>
 497 <span class=special>{</span>
 498 <span class=keyword>public</span><span class=special>:</span>
 499   <span class=keyword>typedef</span> <span class=keyword>typename</span> <span class=identifier>Container</span><span class=special>::</span><span class=identifier>iterator</span> <span class=identifier>handle_type</span><span class=special>;</span>
 500
 501   <span class=identifier>handle_type</span> <span class=identifier>insert</span><span class=special>(</span><span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>Container</span><span class=special>::</span><span class=identifier>value_type</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 502   <span class=keyword>void</span>        <span class=identifier>erase</span><span class=special>(</span><span class=identifier>handle_type</span> <span class=identifier>h</span><span class=special>);</span>
 503   <span class=keyword>const</span> <span class=keyword>typename</span> <span class=identifier>Container</span><span class=special>::</span><span class=identifier>value_type</span><span class=special>&amp;</span> <span class=identifier>entry</span><span class=special>(</span><span class=identifier>handle_type</span> <span class=identifier>h</span><span class=special>);</span>
 504 <span class=special>};</span>
 505 </pre></blockquote>
 506
 507 <p>
 508 <code>Container</code> must be an (ordered or unordered) associative container
 509 such that
 510 <ol>
 511   <li><code>Container::key_type</code> is the same as
 512     <code>Container::value_type</code> (which is the entry type associated to
 513     the factory).
 514   </li>
 515   <li>Unique keys (rather than equivalent keys) are supported.</li>
 516   <li><code>Container</code> is <i>stable</i>, i.e. its iterators are not
 517     invalidated upon insert or erase operations.</li>
 518 </ol>
 519 The equivalence relation associated to <code>assoc_container_factory_class</code>
 520 is the one induced by <code>Container</code>. If equivalence of elements
 521 of <code>Container::value_type</code> is determined solely on the basis of a
 522 type <code>value_type'</code> to which <code>value_type</code> is
 523 implicitly convertible, then <code>assoc_container_factory_class</code> is
 524 a factory of entries of type <code>value_type</code> implicitly associated to
 525 <code>value_type'</code>. For example, the instantiation
 526 </p>
 527
 528 <blockquote><pre>
 529 <span class=identifier>assoc_container_factory_class</span><span class=special>&lt;</span>
 530   <span class=identifier>std</span><span class=special>::</span><span class=identifier>set</span><span class=special>&lt;</span><span class=identifier>derived</span><span class=special>,</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>less</span><span class=special>&lt;</span><span class=identifier>base</span><span class=special>&gt;</span> <span class=special>&gt;</span> <span class=comment>// derived inherits from base</span>
 531 <span class=special>&gt;</span>
 532 </pre></blockquote>
 533
 534 <p>
 535 is a factory of <code>derived</code> elements implicitly associated to
 536 <code>base</code>.
 537 </p>
 538
 539 <h3><a name="assoc_container_factory">Class template <code>assoc_container_factory</code></a></h3>
 540
 541 <p>
 542 <a href="#factory"><code>Factory Specifier</code></a> for <a href="#assoc_container_factory_class"><code>assoc_container_factory_class</code></a>.
 543 </p>
 544
 545 <blockquote><pre>
 546 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>ContainerSpecifier</span><span class=special>&gt;</span>
 547 <span class=keyword>struct</span> <span class=identifier>assoc_container_factory</span><span class=special>;</span>
 548 </pre></blockquote>
 549
 550 <p>
 551 <code>ContainerSpecifier</code> must be an
 552 <a href="../../../mpl/doc/refmanual/lambda-expression.html"><code>MPL Lambda
 553 Expression</code></a> resolving, when invoked with (<code>Entry</code>,
 554 <code>Key</code>), to a type <code>Container</code> such that
 555 <code>assoc_container_factory_class&lt;Container&gt;</code> is a factory
 556 of <code>Entry</code> elements implicitly associated to <code>Key</code>.
 557 </p>
 558
 559 <hr>
 560
 561 <div class="prev_link"><a href="tags.html"><img src="../prev.gif" alt="tags" border="0"><br>
 562 Tags
 563 </a></div>
 564 <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.Flyweight reference" border="0"><br>
 565 Boost.Flyweight reference
 566 </a></div>
 567 <div class="next_link"><a href="holders.html"><img src="../next.gif" alt="holders" border="0"><br>
 568 Holders
 569 </a></div><br clear="all" style="clear: all;">
 570
 571 <br>
 572
 573 <p>Revised August 13th 2008</p>
 574
 575 <p>&copy; Copyright 2006-2008 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
 576 Distributed under the Boost Software
 577 License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
 578 LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
 579 http://www.boost.org/LICENSE_1_0.txt</a>)
 580 </p>
 581
 582 </body>
 583 </html>