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 17Factories reference</h1> 18 19<div class="prev_link"><a href="tags.html"><img src="../prev.gif" alt="tags" border="0"><br> 20Tags 21</a></div> 22<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.Flyweight reference" border="0"><br> 23Boost.Flyweight reference 24</a></div> 25<div class="next_link"><a href="holders.html"><img src="../next.gif" alt="holders" border="0"><br> 26Holders 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> 77Given a type <code>Key</code> and an 78<a href="https://boost.org/sgi/stl/Assignable.html"><code>Assignable</code></a> 79type <code>Entry</code> implicitly convertible to <code>const Key&</code>, a 80<i>factory of <code>Entry</code> elements</i> (implicitly associated to 81<code>Key</code>) is a 82<a href="https://boost.org/sgi/stl/DefaultConstructible.html"><code>Default 83Constructible</code></a> entity able to store and retrieve immutable elements of 84type <code>Entry</code>. A factory is governed by an associated equivalence 85relation defined on <code>Key</code> so that no two 86<code>Entry</code> objects convertible to equivalent <code>Key</code>s 87can be stored simultaneously in the factory. Different factory types can 88use different equivalence relations. 89</p> 90 91<p> 92In the following table, <code>Factory</code> is a factory of elements 93of 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 95value 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="https://boost.org/sgi/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&</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> 142Additionally to the basic thread safety guarantee which is implicitly assumed 143for most classes including the majority of components of the 144C++ standard library, it is required that the member function <code>entry</code> 145can be invoked simultaneously from different threads, even in the presence 146of concurrent accesses to <code>insert</code> and <code>erase</code> (as long 147as the entry returned by <code>entry</code> is not the one which is being 148erased). 149</p> 150 151<p> 152A 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<S>::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<S'></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><</span><span class=keyword>typename</span> <span class=identifier>T</span><span class=special>></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><</span><span class=keyword>typename</span> <span class=identifier>T</span><span class=special>></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> 194Unless specialized by the user, <code>is_factory<T>::type</code> is 195<a href="../../../mpl/doc/refmanual/bool.html"><code>boost::mpl::true_</code></a> 196if <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> 198otherwise. 199</p> 200 201<h3><a name="factory_construct">Class template <code>factory</code></a></h3> 202 203<p> 204<code>factory<T></code> is a syntactic construct meant to indicate 205that <code>T</code> is a factory specifier without resorting to the 206mechanisms 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><</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>></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><</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>></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> 240and <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> 250implemented with a hashed container. 251</p> 252 253<blockquote><pre> 254<span class=keyword>template</span><span class=special><</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>></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>&</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>&</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="https://boost.org/sgi/stl/DefaultConstructible.html"><code>Default 272Constructible</code></a> 273<a href="https://boost.org/sgi/stl/UnaryFunction.html"><code>Unary Function</code></a> 274taking a single argument of type <code>Key</code> and returning a 275value of type <code>std::size_t</code> in the range 276<code>[0, std::numeric_limits<std::size_t>::max())</code>. 277<code>Pred</code> is a 278<a href="https://boost.org/sgi/stl/DefaultConstructible.html"><code>Default 279Constructible</code></a> 280<a href="https://boost.org/sgi/stl/BinaryPredicate.html"> 281<code>Binary Predicate</code></a> inducing an equivalence relation 282on elements of <code>Key</code>. It is required that 283a <code>Hash</code> object return the same value for objects 284equivalent under <code>Pred</code>. 285The equivalence relation on <code>Key</code> associated to the factory is 286that induced by <code>Pred</code>. 287The default arguments for <code>Hash</code> and <code>Pred</code> are 288<a href="../../../functional/hash/index.html"><code>boost::hash<Key></code></a> 289and <code>std::equal_to<Key></code>, respectively. 290<code>Allocator</code> must be an allocator of <code>Entry</code> objects 291satisfying the associated C++ requirements at <b>[lib.allocator.requirements]</b>. 292The default argument is <code>std::allocator<Entry></code>. The internal 293hashed container upon which <code>hashed_factory_class</code> is based is 294constructed 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><</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>></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<Hash,Pred,Allocator></code> is an 311<a href="../../../mpl/doc/refmanual/metafunction-class.html"><code>MPL Metafunction 312Class</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><</span> 317 <span class=identifier>hashed_factory</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>>,</span> 318 <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span> 319<span class=special>>::</span><span class=identifier>type</span> 320</pre></blockquote> 321 322<p> 323is 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><</span> 328 <span class=identifier>hashed_factory_class</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>_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>>,</span> 329 <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span> 330<span class=special>>::</span><span class=identifier>type</span> 331</pre></blockquote> 332 333<p> 334This implies that <code>Hash</code>, <code>Pred</code> and <code>Allocator</code> 335can be 336<a href="../../../mpl/doc/refmanual/placeholder-expression.html"><code>MPL 337Placeholder 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><</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>></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><</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>></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> 370and <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> 380implemented on top of an orderded associative container. 381</p> 382 383<blockquote><pre> 384<span class=keyword>template</span><span class=special><</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>></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>&</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>&</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="https://boost.org/sgi/stl/DefaultConstructible.html"><code>Default 402Constructible</code></a> 403<a href="https://boost.org/sgi/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)&&!c(y,x)</code> for <code>c</code> of type <code>Compare</code>. 407The default argument of <code>Compare</code> is <code>std::less<Key></code>. 408<code>Allocator</code> must be an allocator of <code>Entry</code> objects 409satisfying the associated C++ requirements at <b>[lib.allocator.requirements]</b>. 410The default argument is <code>std::allocator<Entry></code>. The internal 411container upon which <code>set_factory_class</code> is based is 412constructed with default initialized objects of type <code>Compare</code> 413and <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><</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>></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<Compare,Allocator></code> is an 429<a href="../../../mpl/doc/refmanual/metafunction-class.html"><code>MPL Metafunction 430Class</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><</span> 435 <span class=identifier>set_factory</span><span class=special><</span><span class=identifier>Compare</span><span class=special>,</span><span class=identifier>Allocator</span><span class=special>>,</span> 436 <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span> 437<span class=special>>::</span><span class=identifier>type</span> 438</pre></blockquote> 439 440<p> 441is 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><</span> 446 <span class=identifier>set_factory_class</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>_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>>,</span> 447 <span class=identifier>Entry</span><span class=special>,</span><span class=identifier>Key</span> 448<span class=special>>::</span><span class=identifier>type</span> 449</pre></blockquote> 450 451<p> 452This implies that <code>Compare</code> and <code>Allocator</code> 453can be 454<a href="../../../mpl/doc/refmanual/placeholder-expression.html"><code>MPL 455Placeholder 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><</span><span class=keyword>typename</span> <span class=identifier>Container</span><span class=special>></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><</span><span class=keyword>typename</span> <span class=identifier>ContainerSpecifier</span><span class=special>></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> 481and <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 491to 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><</span><span class=keyword>typename</span> <span class=identifier>Container</span><span class=special>></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>&</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>&</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 509such 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> 519The equivalence relation associated to <code>assoc_container_factory_class</code> 520is the one induced by <code>Container</code>. If equivalence of elements 521of <code>Container::value_type</code> is determined solely on the basis of a 522type <code>value_type'</code> to which <code>value_type</code> is 523implicitly convertible, then <code>assoc_container_factory_class</code> is 524a 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><</span> 530 <span class=identifier>std</span><span class=special>::</span><span class=identifier>set</span><span class=special><</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><</span><span class=identifier>base</span><span class=special>></span> <span class=special>></span> <span class=comment>// derived inherits from base</span> 531<span class=special>></span> 532</pre></blockquote> 533 534<p> 535is 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><</span><span class=keyword>typename</span> <span class=identifier>ContainerSpecifier</span><span class=special>></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 553Expression</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<Container></code> is a factory 556of <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> 562Tags 563</a></div> 564<div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.Flyweight reference" border="0"><br> 565Boost.Flyweight reference 566</a></div> 567<div class="next_link"><a href="holders.html"><img src="../next.gif" alt="holders" border="0"><br> 568Holders 569</a></div><br clear="all" style="clear: all;"> 570 571<br> 572 573<p>Revised April 24th 2019</p> 574 575<p>© Copyright 2006-2019 Joaquín M López Muñoz. 576Distributed under the Boost Software 577License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt"> 578LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt"> 579http://www.boost.org/LICENSE_1_0.txt</a>) 580</p> 581 582</body> 583</html> 584
