ceph/src/boost/libs/flyweight/doc/reference/flyweight.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 - flyweight reference</title>
   7 <link rel="stylesheet" href="../style.css" type="text/css">
   8 <link rel="start" href="../index.html">
   9 <link rel="prev" href="index.html">
  10 <link rel="up" href="index.html">
  11 <link rel="next" href="key_value.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 <code>flyweight</code> reference</h1>
  18
  19 <div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.Flyweight reference" border="0"><br>
  20 Boost.Flyweight reference
  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="key_value.html"><img src="../next.gif" alt="key-value flyweights" border="0"><br>
  26 Key-value flyweights
  27 </a></div><br clear="all" style="clear: all;">
  28
  29 <hr>
  30
  31 <h2>Contents</h2>
  32
  33 <ul>
  34   <li><a href="#flyweight_fwd_synopsis">Header
  35     <code>"boost/flyweight/flyweight_fwd.hpp"</code> synopsis</a></li>
  36   <li><a href="#synopsis">Header
  37     <code>"boost/flyweight/flyweight.hpp"</code> synopsis</a>
  38     <ul>
  39       <li><a href="#flyweight">Class template <code>flyweight</code></a>
  40         <ul>
  41           <li><a href="#instantiation_types">Instantiation types</a></li>
  42           <li><a href="#static_init">Static data initialization</a></li>
  43           <li><a href="#constructors">Constructors, copy and assignment</a></li>
  44           <li><a href="#convertibility">Convertibility to the underlying types</a></li>
  45           <li><a href="#modifiers">Modifiers</a></li>
  46           <li><a href="#comparison">Comparison operators</a></li>
  47           <li><a href="#specialized">Specialized algorithms</a></li>
  48           <li><a href="#hash">Hash support</a></li>
  49           <li><a href="#config_macros">Configuration macros</a></li>
  50         </ul>
  51       </li>
  52     </ul>
  53   </li>
  54   <li><a href="#serialize_synopsis">Header
  55     <code>"boost/flyweight/serialize.hpp"</code> synopsis</a>
  56     <ul>
  57       <li><a href="#serialization">Serialization</a></li>
  58     </ul>
  59   </li>
  60 </ul>
  61
  62 <h2>
  63 <a name="flyweight_fwd_synopsis">Header
  64 <a href="../../../../boost/flyweight/flyweight_fwd.hpp"><code>"boost/flyweight/flyweight_fwd.hpp"</code></a>
  65 synopsis</a>
  66 </h2>
  67
  68 <blockquote><pre>
  69 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>functional</span><span class=special>/</span><span class=identifier>hash_fwd</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
  70 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>iosfwd</span><span class=special>&gt;</span>
  71
  72 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
  73
  74 <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
  75
  76 <span class=keyword>template</span><span class=special>&lt;</span>
  77   <span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span>
  78   <span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
  79   <span class=keyword>typename</span> <span class=identifier>Arg2</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
  80   <span class=keyword>typename</span> <span class=identifier>Arg3</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
  81   <span class=keyword>typename</span> <span class=identifier>Arg4</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
  82   <span class=keyword>typename</span> <span class=identifier>Arg5</span><span class=special>=</span><b>implementation defined</b>
  83 <span class=special>&gt;</span>
  84 <span class=keyword>class</span> <span class=identifier>flyweight</span><span class=special>;</span>
  85
  86 <span class=comment>// comparison:
  87
  88 // <b>OP</b> is any of ==,&lt;,!=,&gt;,&gt;=,&lt;=</span>
  89
  90 <span class=keyword>template</span><span class=special>&lt;</span>
  91   <span class=keyword>typename</span> <span class=identifier>T1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg11</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg15</span><span class=special>,</span>
  92   <span class=keyword>typename</span> <span class=identifier>T2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg21</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg25</span>
  93 <span class=special>&gt;</span>
  94 <span class=keyword>bool</span> <span class=keyword>operator</span> <span class=identifier><b><i>OP</i></b></span><span class=special>(</span>
  95   <span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T1</span><span class=special>,</span><span class=identifier>Arg11</span><span class=special>,...,</span><span class=identifier>Arg15</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span>
  96   <span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T2</span><span class=special>,</span><span class=identifier>Arg21</span><span class=special>,...,</span><span class=identifier>Arg25</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
  97
  98 <span class=keyword>template</span><span class=special>&lt;</span>
  99   <span class=keyword>typename</span> <span class=identifier>T1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg11</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg15</span><span class=special>,</span>
 100   <span class=keyword>typename</span> <span class=identifier>T2</span>
 101 <span class=special>&gt;</span>
 102 <span class=keyword>bool</span> <span class=keyword>operator</span> <span class=identifier><b><i>OP</i></b></span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T1</span><span class=special>,</span><span class=identifier>Arg11</span><span class=special>,...,</span><span class=identifier>Arg15</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>T2</span><span class=special>&amp;</span> <span class=identifier>y</span><span class=special>);</span>
 103
 104 <span class=keyword>template</span><span class=special>&lt;</span>
 105   <span class=keyword>typename</span> <span class=identifier>T1</span><span class=special>,</span>
 106   <span class=keyword>typename</span> <span class=identifier>T2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg21</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg25</span>
 107 <span class=special>&gt;</span>
 108 <span class=keyword>bool</span> <span class=keyword>operator</span> <span class=identifier><b><i>OP</i></b></span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>T1</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>,</span><span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T2</span><span class=special>,</span><span class=identifier>Arg21</span><span class=special>,...,</span><span class=identifier>Arg25</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
 109
 110 <span class=comment>// specialized algorithms:</span>
 111
 112 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg5</span><span class=special>&gt;</span>
 113 <span class=keyword>inline</span> <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span>
 114   <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Arg1</span><span class=special>,...,</span><span class=identifier>Arg5</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>,</span><span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Arg1</span><span class=special>,...,</span><span class=identifier>Arg5</span><span class=special>&gt;&amp;</span> <span class=identifier>y</span><span class=special>);</span>
 115
 116 <span class=keyword>template</span><span class=special>&lt;</span>
 117   <span class=keyword>typename</span> <span class=identifier>ElemType</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Traits</span><span class=special>,</span>
 118   <span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg5</span>
 119 <span class=special>&gt;</span>
 120 <span class=keyword>inline</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>basic_ostream</span><span class=special>&lt;</span><span class=identifier>ElemType</span><span class=special>,</span><span class=identifier>Traits</span><span class=special>&gt;&amp;</span> <span class=keyword>operator</span><span class=special>&lt;&lt;(</span>
 121   <span class=identifier>std</span><span class=special>::</span><span class=identifier>basic_ostream</span><span class=special>&lt;</span><span class=identifier>ElemType</span><span class=special>,</span><span class=identifier>Traits</span><span class=special>&gt;&amp;</span> <span class=identifier>out</span><span class=special>,</span>
 122   <span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Arg1</span><span class=special>,...,</span><span class=identifier>Arg5</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 123
 124 <span class=keyword>template</span><span class=special>&lt;</span>
 125   <span class=keyword>typename</span> <span class=identifier>ElemType</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Traits</span><span class=special>,</span>
 126   <span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg5</span>
 127 <span class=special>&gt;</span>
 128 <span class=keyword>inline</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>basic_ostream</span><span class=special>&lt;</span><span class=identifier>ElemType</span><span class=special>,</span><span class=identifier>Traits</span><span class=special>&gt;&amp;</span> <span class=keyword>operator</span><span class=special>&gt;&gt;(</span>
 129   <span class=identifier>std</span><span class=special>::</span><span class=identifier>basic_istream</span><span class=special>&lt;</span><span class=identifier>ElemType</span><span class=special>,</span><span class=identifier>Traits</span><span class=special>&gt;&amp;</span> <span class=identifier>in</span><span class=special>,</span>
 130   <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Arg1</span><span class=special>,...,</span><span class=identifier>Arg5</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 131
 132 <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
 133
 134 <span class=keyword>using</span> <span class=identifier>flyweights</span><span class=special>::</span><span class=identifier>flyweight</span><span class=special>;</span>
 135
 136 <span class=special>}</span> <span class=comment>// namespace boost</span>
 137
 138 <span class=comment>// hash support:</span>
 139
 140 <span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
 141
 142 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>class</span> <span class=identifier>T</span><span class=special>&gt;</span> <span class=keyword>struct</span> <span class=identifier>hash</span><span class=special>;</span>
 143 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg5</span><span class=special>&gt;</span>
 144 <span class=keyword>struct</span> <span class=identifier>hash</span><span class=special>&lt;</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Arg1</span><span class=special>,...,</span><span class=identifier>Arg5</span><span class=special>&gt;</span> <span class=special>&gt;;</span>
 145
 146 <span class=special>}</span> <span class=comment>// namespace std</span>
 147
 148 <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
 149 <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
 150
 151 <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>,...,</span><span class=keyword>typename</span> <span class=identifier>Arg5</span><span class=special>&gt;</span>
 152 <span class=keyword>inline</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>hash_value</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Arg1</span><span class=special>,...,</span><span class=identifier>Arg5</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 153
 154 <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
 155 <span class=special>}</span> <span class=comment>// namespace boost</span>
 156 </pre></blockquote>
 157
 158 <p>
 159 <code>flyweight_fwd.hpp</code> forward declares the class template
 160 <a href="#flyweight"><code>flyweight</code></a> and its associated global functions and class template specializations.
 161 </p>
 162
 163 <h2>
 164 <a name="synopsis">Header
 165 <a href="../../../../boost/flyweight/flyweight.hpp"><code>"boost/flyweight/flyweight.hpp"</code></a>
 166 synopsis</a>
 167 </h2>
 168
 169 <h3><a name="flyweight">
 170 Class template <code>flyweight</code>
 171 </a></h3>
 172
 173 <p>
 174 Objects of type <code>flyweight&lt;...&gt;</code> provide access to immutable
 175 values of type <code>flyweight&lt;...&gt;::value_type</code>, with the following advantages over using
 176 plain <code>value_type</code> objects:
 177 <ul>
 178   <li>Flyweight objects with equivalent value share the same representation
 179     (the associated <code>value_type</code> object).
 180   </li>
 181   <li>The size of flyweights is typically that of a pointer, which is in general
 182     smaller than <code>sizeof(value_type)</code>.
 183   </li>
 184 </ul>
 185
 186 So, if the level of redundancy (ratio of total objects to different values)
 187 is high enough, substituting a suitable instantiation of <code>flyweight</code>
 188 for <code>value_type</code> results in a reduction in memory usage.
 189 </p>
 190
 191 <p>
 192 <code>flyweight</code> is parameterized according to some aspects:
 193 <ul>
 194   <li>Types <code>key_value</code> and <code>value_type</code>
 195     (possibly equal), where <code>key_type</code> serves as a
 196     key type to lookup and construct internal shared instances of
 197     objects of <code>value_type</code>.
 198   </li>
 199   <li>An optional <a href="tags.html#tag">tag</a> type meant to syntactically
 200      differentiate between otherwise identical instantiations.
 201   </li>
 202   <li>The <a href="factories.html#factory">factory class</a> used to store
 203     and retrieve the shared value objects.
 204   </li>
 205   <li>The type of <a href="holders.html#holder">holder</a> used to
 206     instantiate the flyweight factory and a mutex object, both of
 207     which are unique to each specialization of the <code>flyweight</code>
 208     class template.
 209   </li>
 210   <li>A <a href="locking.html#locking">locking policy</a> determining
 211     the synchronization mechanisms for internal access to shared resources.
 212   </li>
 213   <li>A <a href="tracking.html#tracking">tracking policy</a> which controls
 214    how values are treated when all their associated flyweight objects are
 215    destroyed.
 216   </li>
 217 </ul>
 218 These aspects impact the internal structure and behavior
 219 of the <code>flyweight</code> instantiation in the following manner:
 220 <ul>
 221   <li>Each instantation of <code>flyweight</code> internally owns
 222     a unique factory object and a unique synchronization
 223     <a href="locking.html#preliminary">mutex</a> object, both of which
 224     are created through the use of an associated holder type.
 225   </li>
 226   <li>The flyweight factory stores elements of an undisclosed type
 227     <code>Entry</code> that is implicitly convertible to
 228     <code>const key_type&amp;</code> and also stores a subobject of
 229     <code>value_type</code>. Every flyweight object is associated
 230     to a <code>value_type</code> subobject of some <code>Entry</code>
 231     stored in the factory.
 232   </li>
 233   <li>The associated mutex object is used to protect all invocations
 234     to the insertion and deletion functions of the internal flyweight
 235     factory.
 236   </li>
 237   <li>Each flyweight object internally stores a value of some
 238     undisclosed type <code>Handle</code>. <code>Handle</code> and
 239     the <code>Entry</code> type referred to above are obtained
 240     from invocations to the associated tracking policy, in the
 241     manner described for this concept.
 242   </li>
 243 </ul>
 244 In what follows, we implicitly assume that <code>key_type</code> equivalence
 245 refers to the equivalence relationship induced by the factory class used.
 246 Also, two values of <code>value_type</code> are considered equivalent
 247 if they are constructed from equivalent keys, or are copies of
 248 objects constructed from equivalent keys.
 249 </p>
 250
 251 <blockquote><pre>
 252 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>initializer_list</span><span class=special>&gt;</span>
 253
 254 <span class=keyword>template</span><span class=special>&lt;</span>
 255   <span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span>
 256   <span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg2</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg3</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg4</span><span class=special>,</span><span class=keyword>typename</span> <span class=identifier>Arg5</span>
 257 <span class=special>&gt;</span>
 258 <span class=keyword>class</span> <span class=identifier>flyweight</span>
 259 <span class=special>{</span>
 260 <span class=keyword>public</span><span class=special>:</span>
 261   <span class=keyword>typedef</span> <span class=identifier><b>dependent on T</b></span> <span class=identifier>key_type</span><span class=special>;</span>
 262   <span class=keyword>typedef</span> <span class=identifier><b>dependent on T</b></span> <span class=identifier>value_type</span><span class=special>;</span>
 263
 264   <span class=comment>// static data initialization:</span>
 265
 266   <span class=keyword>static</span> <span class=keyword>bool</span> <span class=identifier>init</span><span class=special>();</span>
 267   <span class=keyword>class</span> <span class=identifier>initializer</span><span class=special>{</span><span class=keyword>public</span><span class=special>:</span><span class=identifier>initializer</span><span class=special>();</span><span class=special>};</span>
 268
 269   <span class=comment>// construct/copy/destroy:</span>
 270
 271   <span class=identifier>flyweight</span><span class=special>();</span>
 272
 273   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span><span class=special>...</span> <span class=identifier>Args</span><span class=special>&gt;</span>
 274   <span class=keyword>explicit</span> <span class=identifier>flyweight</span><span class=special>(</span><span class=identifier>Args</span><span class=special>&amp;&amp;...</span> <span class=identifier>args</span><span class=special>);</span>
 275
 276   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>V</span><span class=special>&gt;</span>
 277   <span class=identifier>flyweight</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>&gt;</span> <span class=identifier>list</span><span class=special>);</span>
 278
 279   <span class=identifier>flyweight</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 280   <span class=identifier>flyweight</span><span class=special>(</span><span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 281   <span class=identifier>flyweight</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&amp;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 282   <span class=identifier>flyweight</span><span class=special>(</span><span class=identifier>flyweight</span><span class=special>&amp;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 283
 284   <span class=keyword>explicit</span> <span class=identifier>flyweight</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 285   <span class=keyword>explicit</span> <span class=identifier>flyweight</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>
 286   <span class=keyword>explicit</span> <span class=identifier>flyweight</span><span class=special>(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&amp;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 287   <span class=keyword>explicit</span> <span class=identifier>flyweight</span><span class=special>(</span><span class=identifier>value_type</span><span class=special>&amp;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 288
 289   <span class=keyword>template</span><span class=special>&lt;</span><span class=keyword>typename</span> <span class=identifier>V</span><span class=special>&gt;</span>
 290   <span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>=(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>initializer_list</span><span class=special>&lt;</span><span class=identifier>V</span><span class=special>&gt;</span> <span class=identifier>list</span><span class=special>);</span>
 291
 292   <span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>=(</span><span class=keyword>const</span> <span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 293
 294   <span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>=(</span><span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 295   <span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=keyword>operator</span><span class=special>=(</span><span class=identifier>value_type</span><span class=special>&amp;&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 296
 297   <span class=comment>// convertibility to underlying type:</span>
 298
 299   <span class=keyword>const</span> <span class=identifier>key_type</span><span class=special>&amp;</span>   <span class=identifier>get_key</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
 300   <span class=keyword>const</span> <span class=identifier>value_type</span><span class=special>&amp;</span> <span class=identifier>get</span><span class=special>()</span><span class=keyword>const</span><span class=special>;</span>
 301   <span class=keyword>operator</span> <span class=keyword>const</span>    <span class=identifier>value_type</span><span class=special>&amp;()</span><span class=keyword>const</span><span class=special>;</span>
 302
 303   <span class=comment>// modifiers:</span>
 304
 305   <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span><span class=identifier>flyweight</span><span class=special>&amp;</span> <span class=identifier>x</span><span class=special>);</span>
 306 <span class=special>};</span>
 307 </pre></blockquote>
 308
 309 <h4><a name="instantiation_types">Instantiation types</a></h4>
 310
 311 <p>
 312 <code>T</code> can be either:
 313 <ul>
 314   <li>An arbitrary type,</li>
 315   <li>a type of the form
 316     <a href="key_value.html#key_value_construct"><code>key_value&lt;Key,Value[,KeyFromValue]&gt;</code></a>.</li>
 317 </ul>
 318 In the first case, the nested types <code>key_type</code> and <code>value_type</code>
 319 are both equal to <code>T</code>. In the second case, <code>key_type</code>=<code>Key</code>,
 320 <code>value_type</code>=<code>Value</code>; we say then that the instantiation
 321 of <code>flyweight</code> is a <i>key-value</i> flyweight.
 322 <code>value_type</code> is the type of the values flyweight objects give access to,
 323 while value lookup is based on associated <code>key_type</code> values.
 324 <code>key_value</code> must be
 325 <a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>
 326 and <code>value_type</code> must be constructible from <code>key_type</code>;
 327 additionally, <code>key_value</code> must
 328 conform to any extra requirements imposed by the type of factory used.
 329 For key-value flyweights, it is guaranteed that the creation or assignment of a flyweight
 330 object results in at most one construction (or copy construction in some
 331 particular cases) of an object
 332 of <code>value_type</code>, and this construction only occurs in the case that no
 333 equivalent value existed previously in the flyweight factory.
 334 </p>
 335
 336 <p>
 337 The types <code>Arg1</code>, ... , <code>Arg5</code>, if provided, must be any
 338 of the following, in no particular order:
 339 <ul>
 340   <li>A <a href="tags.html#tag">tag</a>,</li>
 341   <li>a <a href="factories.html#factory">factory specifier</a>,</li>
 342   <li>a <a href="holders.html#holder">holder specifier</a>,</li>
 343   <li>a <a href="locking.html#locking">locking policy</a>,</li>
 344   <li>a <a href="tracking.html#tracking">tracking policy</a>.</li>
 345 </ul>
 346 No aspect can be specified twice. Each internal component of the
 347 <code>flyweight</code> instantiation is obtained through use of the
 348 corresponding specifier; for instance, the factory results from a
 349 certain (MPL) invocation of the given factory specifier, the internal
 350 mutex from the given locking policy, etc.
 351 The default configuration arguments are:
 352 <ul>
 353   <li>No tagging,</li>
 354   <li><a href="factories.html#hashed_factory"><code>hashed_factory&lt;&gt;</code></a>,</li>
 355   <li><a href="holders.html#static_holder"><code>static_holder</code></a>,</li>
 356   <li><a href="locking.html#simple_locking"><code>simple_locking</code></a>,</li>
 357   <li><a href="tracking.html#refcounted"><code>refcounted</code></a> tracking policy.</li>
 358 </ul>
 359 </p>
 360
 361 <h4><a name="static_init">Static data initialization</a></h4>
 362
 363 <p>
 364 The static data internal to a given <code>flyweight</code> instantiation
 365 (factory instance, etc.) is constructed during the dynamic initialization
 366 phase of the program and always before the first program-wide use of the
 367 instantiated class. The following utilities can be
 368 used when more control about the moment of construction is required.
 369 </p>
 370
 371 <code>static bool init();</code>
 372
 373 <blockquote>
 374 <b>Effects:</b> After execution of this function the static data associated
 375 to the instantiation of <code>flyweight</code> is guaranteed to be
 376 constructed.<br>
 377 <b>Note:</b> Concurrent execution of this function is not thread safe.
 378 </blockquote>
 379
 380 <code>initializer::initializer();</code>
 381
 382 <blockquote>
 383 <b>Effects:</b> Executes <code>init()</code>.
 384 </blockquote>
 385
 386 <h4><a name="constructors">Constructors, copy and assignment</a></h4>
 387
 388 <code>flyweight();</code>
 389
 390 <blockquote>
 391 <b>Effects:</b> Constructs a <code>flyweight</code> object with the value
 392 <code>value_type(key_type())</code>
 393 if <code>flyweight</code> is key-value
 394 or <code>value_type()</code>
 395 otherwise.
 396 </blockquote>
 397
 398 <a name="fwd_ctor">
 399 <code>template&lt;typename... Args&gt;<br>
 400 explicit flyweight(Args&amp;&amp;... args);</code></a>
 401
 402 <blockquote>
 403 <b>Effects:</b> Constructs a <code>flyweight</code> object with the value
 404 <code>value_type(key_type(std::forward&lt;Args&gt;(args)...))</code>
 405 if <code>flyweight</code> is key-value
 406 or <code>value_type(std::forward&lt;Args&gt;(args)...)</code>
 407 otherwise.<br>
 408 <b>Note:</b> In compilers without variadic template support, the implementation
 409 replaces this constructor with a number of overloads accepting
 410 any combination of const/non-const lvalue/rvalue reference arguments
 411 up to a maximum number that
 412 can be globally <a href="#limit_num_ctor_args">configured</a> by the user.
 413 </blockquote>
 414
 415 <code>template&lt;typename V&gt;<br>
 416 flyweight(std::initializer_list&lt;V&gt; list);</code>
 417
 418 <blockquote>
 419 <b>Effects:</b> Constructs a <code>flyweight</code> object with the value
 420 <code>value_type(key_type(list))</code> if <code>flyweight</code> is key-value
 421 or <code>value_type(list)</code> otherwise.<br>
 422 <b>Note:</b> The specialization for a particular <code>std::initializer_list&lt;V'&gt;</code>
 423 of this member function template is not available unless
 424 <code>key_type</code> is constructible from
 425 <code>std::initializer_list&lt;V'&gt;</code>.
 426 </blockquote>
 427
 428 <code>flyweight(const flyweight&amp; x);<br>
 429 flyweight(flyweight&amp; x);<br>
 430 flyweight(const flyweight&amp;&amp; x);<br>
 431 flyweight(flyweight&amp;&amp; x);</code>
 432
 433 <blockquote>
 434 <b>Effects:</b> Constructs a <code>flyweight</code> object associated to
 435 the same value as <code>x</code>.<br>
 436 <b>Exception safety:</b> <code>nothrow</code>.
 437 </blockquote>
 438
 439 <code>explicit flyweight(const value_type&amp; x);<br>
 440 explicit flyweight(value_type&amp; x);<br>
 441 explicit flyweight(const value_type&amp;&amp; x);<br>
 442 explicit flyweight(value_type&amp;&amp; x);</code>
 443
 444 <blockquote>
 445 <b>Requires:</b> If <code>flyweight</code> is key-value,
 446 <code>value_type</code> is
 447 <a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>
 448 and the
 449 <a href="key_value.html#key_extractor"><code>Key Extractor</code></a>
 450 <code>KeyFromValue</code> must have been supplied as part of the
 451 <code>key_value&lt;&gt;</code> construct.<br>
 452 <b>Effects:</b> Constructs a <code>flyweight</code> associated to a
 453 copy of <code>x</code> or with a <code>value_type</code> constructed
 454 from a key equivalent to that associated to <code>x</code>. For non-key-value
 455 flyweights, <code>x</code> is its own key; for key-value flyweights,
 456 the key is extracted through use of an object of type <code>KeyFromValue</code>.<br>
 457 </blockquote>
 458
 459 <code>template&lt;typename V&gt;<br>
 460 flyweight&amp; operator=(std::initializer_list&lt;V&gt; list);</code>
 461
 462 <blockquote>
 463 <b>Effects:</b> <code>*this=flyweight(list)</code>.<br>
 464 <b>Returns:</b> <code>*this</code>.<br>
 465 <b>Note:</b> The specialization for a particular <code>std::initializer_list&lt;V'&gt;</code>
 466 of this member function template is not available unless
 467 <code>key_type</code> is constructible from
 468 <code>std::initializer_list&lt;V'&gt;</code>.
 469 </blockquote>
 470
 471 <code>flyweight&amp; operator=(const flyweight&amp; x);</code>
 472
 473 <blockquote>
 474 <b>Effects:</b> Associates the <code>flyweight</code> object with the same value
 475 as <code>x</code>.<br>
 476 <b>Returns:</b> <code>*this</code>.<br>
 477 <b>Exception safety:</b> <code>nothrow</code>.
 478 </blockquote>
 479
 480 <code>flyweight&amp; operator=(const value_type&amp; x);<br>
 481 flyweight&amp; operator=(value_type&amp;&amp; x);</code>
 482
 483 <blockquote>
 484 <b>Effects:</b> <code>*this=flyweight(x)</code> (first overload),
 485 <code>*this=flyweight(std::move(x))</code> (second overload).<br>
 486 <b>Returns:</b> <code>*this</code>.<br>
 487 </blockquote>
 488
 489 <h4><a name="convertibility">Convertibility to the underlying types</a></h4>
 490
 491 <code>const key_type&amp; get_key()const;</code>
 492
 493 <blockquote>
 494 <b>Returns:</b> A copy of the key used to construct the
 495 <code>value_type</code> associated to the <code>flyweight</code>
 496 object.<br>
 497 <b>Exception safety:</b> If <code>flyweight</code> is not key-value or
 498 if <code>KeyFromValue</code> was not provided, <code>nothrow</code>.
 499 </blockquote>
 500
 501 <code>const value_type&amp; get()const;<br>
 502         operator const value_type&amp;()const;</code>
 503
 504 <blockquote>
 505 <b>Returns:</b> The value associated to the <code>flyweight</code>
 506 object.<br>
 507 <b>Exception safety:</b> <code>nothrow</code>.
 508 </blockquote>
 509
 510 <h4><a name="modifiers">Modifiers</a></h4>
 511
 512 <code>void swap(flyweight&amp; x);</code>
 513
 514 <blockquote>
 515 <b>Effects:</b> Swaps the associations to <code>value_type</code>s each
 516 flyweight object has. No swapping of <code>key_type</code> or
 517 <code>value_type</code> objects is done.<br>
 518 <b>Exception safety:</b> <code>nothrow</code>.
 519 </blockquote>
 520
 521 <h4><a name="comparison">Comparison operators</a></h4>
 522
 523 <code>template&lt;<br>
 524 &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
 525 &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
 526 &gt;<br>
 527 bool operator ==(<br>
 528 &nbsp;&nbsp;const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,<br>
 529 &nbsp;&nbsp;const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
 530
 531 <blockquote>
 532 <b>Returns:</b> If <code>x</code> and <code>y</code> are of the same type, returns
 533 <code>true</code> if and only if they are associated to the same value; if
 534 <code>x</code> and <code>y</code> have different types, returns
 535 <code>x.get()==y.get()</code>.<br>
 536 <b>Exception safety:</b> If <code>x</code> and <code>y</code> are of the same type,
 537 <code>nothrow</code>.
 538 </blockquote>
 539
 540 <code>template&lt;<br>
 541 &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
 542 &nbsp;&nbsp;typename T2<br>
 543 &gt;<br>
 544 bool operator ==(const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,const T2&amp; y);</code>
 545
 546 <blockquote>
 547 <b>Returns:</b> <code>x.get()==y</code>.
 548 </blockquote>
 549
 550 <code>template&lt;<br>
 551 &nbsp;&nbsp;typename T1,<br>
 552 &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
 553 &gt;<br>
 554 bool operator ==(const T1&amp; x,const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
 555
 556 <blockquote>
 557 <b>Returns:</b> <code>x==y.get()</code>.
 558 </blockquote>
 559
 560 <code>template&lt;<br>
 561 &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
 562 &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
 563 &gt;<br>
 564 bool operator &lt;(<br>
 565 &nbsp;&nbsp;const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,<br>
 566 &nbsp;&nbsp;const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
 567
 568 <blockquote>
 569 <b>Returns:</b> <code>x.get()&lt;y.get()</code>.
 570 </blockquote>
 571
 572 <code>template&lt;<br>
 573 &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
 574 &nbsp;&nbsp;typename T2<br>
 575 &gt;<br>
 576 bool operator &lt;(const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,const T2&amp; y);</code>
 577
 578 <blockquote>
 579 <b>Returns:</b> <code>x.get()&lt;y</code>.
 580 </blockquote>
 581
 582 <code>template&lt;<br>
 583 &nbsp;&nbsp;typename T1,<br>
 584 &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
 585 &gt;<br>
 586 bool operator &lt;(const T1&amp; x,const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
 587
 588 <blockquote>
 589 <b>Returns:</b> <code>x&lt;y.get()</code>.
 590 </blockquote>
 591
 592
 593 <code>template&lt;<br>
 594 &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
 595 &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
 596 &gt;<br>
 597 bool operator <b><i>OP</i></b>(<br>
 598 &nbsp;&nbsp;const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,<br>
 599 &nbsp;&nbsp;const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);<br>
 600 template&lt;<br>
 601 &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
 602 &nbsp;&nbsp;typename T2<br>
 603 &gt;<br>
 604 bool operator <b><i>OP</i></b>(const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,const T2&amp; y);</br>
 605 template&lt;<br>
 606 &nbsp;&nbsp;typename T1,<br>
 607 &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
 608 &gt;<br>
 609 bool operator <b><i>OP</i></b>(const T1&amp; x,const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
 610
 611 <p>
 612 (<code><b><i>OP</i></b></code> is any of <code>!=</code>, <code>></code>,
 613 <code>>=</code>, <code>&lt;=</code>.)
 614 </p>
 615
 616 <blockquote>
 617 <b>Returns:</b> <code>true</code> if and only if
 618 <blockquote>
 619 <code>!(x==y)</code> (<code><b><i>OP</i></b></code> is <code>!=</code>),<br>
 620 <code>&nbsp;&nbsp;y&lt;&nbsp;x&nbsp;</code> (<code><b><i>OP</i></b></code> is <code>>&nbsp;</code>),<br>
 621 <code>!(x&lt;&nbsp;y)</code> (<code><b><i>OP</i></b></code> is <code>>=</code>),<br>
 622 <code>!(y&lt;&nbsp;x)</code> (<code><b><i>OP</i></b></code> is <code>&lt;=</code>).
 623 </blockquote>
 624 </blockquote>
 625
 626 <h4><a name="specialized">Specialized algorithms</a></h4>
 627
 628 <code>template&lt;typename T,typename Arg1,...,typename Arg5&gt;<br>
 629 inline void swap(<br>
 630 &nbsp;&nbsp;flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x,flyweight&lt;T,Arg1,...,Arg5&gt;&amp; y);</code>
 631
 632 <blockquote>
 633 <b>Effects:</b> <code>x.swap(y)</code>.
 634 </blockquote>
 635
 636 <code>template&lt;<br>
 637 &nbsp;&nbsp;typename ElemType,typename Traits, <br>
 638 &nbsp;&nbsp;typename T,typename Arg1,...,typename Arg5<br>
 639 &gt;<br>
 640 inline std::basic_ostream&lt;ElemType,Traits&gt;&amp; operator&lt;&lt;(<br>
 641 &nbsp;&nbsp;std::basic_ostream&lt;ElemType,Traits&gt;&amp; out,<br>
 642 &nbsp;&nbsp;const flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x);</code>
 643
 644 <blockquote>
 645 <b>Effects:</b> <code>out&lt;&lt;x.get()</code>.<br>
 646 <b>Returns:</b> <code>out</code>.
 647 </blockquote>
 648
 649 <code>template&lt;<br>
 650 &nbsp;&nbsp;typename ElemType,typename Traits, <br>
 651 &nbsp;&nbsp;typename T,typename Arg1,...,typename Arg5<br>
 652 &gt;<br>
 653 inline std::basic_ostream&lt;ElemType,Traits&gt;&amp; operator&gt;&gt;(<br>
 654 &nbsp;&nbsp;std::basic_istream&lt;ElemType,Traits&gt;&amp; in,<br>
 655 &nbsp;&nbsp;flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x);</code>
 656
 657 <blockquote>
 658 <b>Requires:</b> If <code>flyweight</code> is key-value,
 659 <code>value_type</code> is
 660 <a href="http://www.sgi.com/tech/stl/Assignable.html"><code>Assignable</code></a>
 661 and the
 662 <a href="key_value.html#key_extractor"><code>Key Extractor</code></a>
 663 <code>KeyFromValue</code> must have been supplied as part of the
 664 <code>key_value&lt;&gt;</code> construct.<br>
 665 <b>Effects:</b> Reads an object of type <code>value_type</code> from <code>in</code>
 666 and assigns it to <code>x</code>.<br>
 667 <b>Returns:</b> <code>in</code>.
 668 </blockquote>
 669
 670 <h4><a name="hash">Hash support</a></h4>
 671
 672 <p>
 673 Support is provided for hashing <code>flyweight</code>s both with <code>std::hash</code> and
 674 <a href="../../../../doc/html/hash.html"><code>boost::hash</code></a>. In either case, the calculation
 675 does not involve hashing the associated <code>value_type</code> objects themselves; so, it is
 676 immaterial whether <code>value_type</code> is hashable or not.
 677 The results given by <code>std::hash</code> and <code>boost::hash</code> for the same
 678 <code>flyweight</code> object will usually differ.<br />
 679 <b>Note:</b> Hash support can be <a href="#disable_hash_support">disabled</a> to solve
 680 clashes with code where this has already been defined by the user.
 681 </p>
 682
 683 <code>namespace std{<br>
 684 template&lt;typename T,typename Arg1,...,typename Arg5&gt;<br>
 685 struct hash&lt;boost::flyweight&lt;T,Arg1,...,Arg5&gt; &gt;;<br>
 686 }</code>
 687
 688 <blockquote>
 689 This template specialization meets the requirements of class template <code>std::hash</code> in <b>[unord.hash]</b>.
 690 No exception is thrown when invoking instances of this specialization.
 691 </blockquote>
 692
 693 <code>template&lt;typename T,typename Arg1,...,typename Arg5&gt;<br>
 694 inline std::size_t hash_value(const flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x);</code>
 695
 696 <blockquote>
 697 <b>Returns:</b> A hash value for <code>x</code> to be used by
 698 <a href="../../../../doc/html/hash/custom.html">Boost.Hash</a>.<br>
 699 <b>Exception safety:</b> <code>nothrow</code>.
 700 </blockquote>
 701
 702 <h4><a name="config_macros">Configuration macros</a></h4>
 703
 704 <a name="limit_num_ctor_args">
 705 <code>BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS</code></a>
 706
 707 <blockquote>
 708 In compilers without variadic template support,
 709 globally define this macro to set the maximum number of
 710 arguments accepted by <code>flyweight</code>
 711 <a href="#fwd_ctor">forwarding constructor</a>, which by default
 712 is 5.
 713 </blockquote>
 714
 715 <a name="disable_hash_support">
 716 <code>BOOST_FLYWEIGHT_DISABLE_HASH_SUPPORT</code></a>
 717
 718 <blockquote>
 719 If defined, hash support is not provided. This can be useful to cope
 720 with legacy code where general <code>flyweight</code> hashing has already been
 721 defined by the user.
 722 </blockquote>
 723
 724 <h2>
 725 <a name="serialize_synopsis">Header
 726 </a><a href="../../../../boost/flyweight/serialize.hpp"><code>"boost/flyweight/serialize.hpp"</code></a>
 727 synopsis
 728 </h2>
 729
 730 <p>
 731 <code>serialize.hpp</code> includes the necessary functionality for interoperability
 732 of <code>flyweight</code> with
 733 <a href="../../../serialization/index.html">Boost.Serialization</a>.
 734 </p>
 735
 736 <h3><a name="serialization">Serialization</a></h3>
 737
 738 <p>
 739 <code>flyweight</code>s can be archived and retrieved by means of
 740 <a href="../../../serialization/index.html">Boost.Serialization</a>. Regular as well
 741 as XML archives are supported.
 742 Serialization is done in an efficient manner so that saving equivalent <code>flyweight</code>s
 743 result in their common <code>key_type</code> value being stored only once, regardless
 744 of whether <code>key_type</code> is
 745 <a href="../../../serialization/doc/traits.html#tracking">tracked</a> by
 746 Boost.Serialization or not.
 747 </p>
 748
 749 Operation: saving of a <code>flyweight</code> object <code>x</code> to an
 750 output archive (XML archive) <code>ar</code>.
 751
 752 <blockquote>
 753 <b>Requires:</b> <code>key_type</code> is serializable (XML-serializable).<br>
 754 <b>Effects:</b> The value <code>k=x.get_key()</code> is saved into <code>ar</code> as
 755 part of this operation or of a previous saving operation of a <code>flyweight</code>
 756 object with the same key.<br>
 757 <b>Exception safety:</b> Strong with respect to <code>x</code>. If an exception
 758 is thrown, <code>ar</code> may be left in an inconsistent state.
 759 </blockquote>
 760
 761 Operation: loading of a <code>flyweight</code> <code>x'</code> from an
 762 input archive (XML archive) <code>ar</code>.
 763
 764 <blockquote>
 765 <b>Requires:</b> <code>key_type</code> is serializable (XML-serializable).<br>
 766 <b>Effects:</b> <code>x'</code> is associated to a value constructed from a key
 767 equivalent to <code>k'</code>, a restored copy of the value <code>k</code>
 768 defined above.<br>
 769 <b>Exception safety:</b> Strong with respect to <code>x'</code>. If an exception
 770 is thrown, <code>ar</code> may be left in an inconsistent state.
 771 </blockquote>
 772
 773 <hr>
 774
 775 <div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.Flyweight reference" border="0"><br>
 776 Boost.Flyweight reference
 777 </a></div>
 778 <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.Flyweight reference" border="0"><br>
 779 Boost.Flyweight reference
 780 </a></div>
 781 <div class="next_link"><a href="key_value.html"><img src="../next.gif" alt="key-value flyweights" border="0"><br>
 782 Key-value flyweights
 783 </a></div><br clear="all" style="clear: all;">
 784
 785 <br>
 786
 787 <p>Revised November 11th 2014</p>
 788
 789 <p>&copy; Copyright 2006-2014 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
 790 Distributed under the Boost Software
 791 License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
 792 LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
 793 http://www.boost.org/LICENSE_1_0.txt</a>)
 794 </p>
 795
 796 </body>
 797 </html>