Home Explore Help
Register Sign In
devn00b
/
EQ2EMu
9
3
Fork 0
Files Issues 59 Pull Requests 0 Wiki
Tree: 60a9c87312
Branches Tags
EQ2EMu
/
EQ2
/
source
/
depends
/
boost_1_72_0
/
libs
/
flyweight
/
doc
/
reference
/
flyweight.html

flyweight.html 44 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797 
  1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0.1 Transitional//EN">
    2. 

  2. 

  3. <html>
    4. 

  4. <head>
    5. 

  5. <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    6. 

  6. <title>Boost.Flyweight Documentation - flyweight reference</title>
    7. 

  7. <link rel="stylesheet" href="../style.css" type="text/css">
    8. 

  8. <link rel="start" href="../index.html">
    9. 

  9. <link rel="prev" href="index.html">
    10. 

  10. <link rel="up" href="index.html">
    11. 

  11. <link rel="next" href="key_value.html">
    12. 

  12. </head>
    13. 

  13. 

  14. <body>
    15. 

  15. <h1><img src="../../../../boost.png" alt="Boost logo" align=
    16. 

  16. "middle" width="277" height="86">Boost.Flyweight
    17. 

  17. <code>flyweight</code> reference</h1>
    18. 

  18. 

  19. <div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.Flyweight reference" border="0"><br>
    20. 

  20. Boost.Flyweight reference
    21. 

  21. </a></div>
    22. 

  22. <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.Flyweight reference" border="0"><br>
    23. 

  23. Boost.Flyweight reference
    24. 

  24. </a></div>
    25. 

  25. <div class="next_link"><a href="key_value.html"><img src="../next.gif" alt="key-value flyweights" border="0"><br>
    26. 

  26. Key-value flyweights
    27. 

  27. </a></div><br clear="all" style="clear: all;">
    28. 

  28. 

  29. <hr>
    30. 

  30. 

  31. <h2>Contents</h2>
    32. 

  32. 

  33. <ul>
    34. 

  34.   <li><a href="#flyweight_fwd_synopsis">Header
    35. 

  35.     <code>"boost/flyweight/flyweight_fwd.hpp"</code> synopsis</a></li>
    36. 

  36.   <li><a href="#synopsis">Header
    37. 

  37.     <code>"boost/flyweight/flyweight.hpp"</code> synopsis</a>
    38. 

  38.     <ul>
    39. 

  39.       <li><a href="#flyweight">Class template <code>flyweight</code></a>
    40. 

  40.         <ul>
    41. 

  41.           <li><a href="#instantiation_types">Instantiation types</a></li>
    42. 

  42.           <li><a href="#static_init">Static data initialization</a></li>
    43. 

  43.           <li><a href="#constructors">Constructors, copy and assignment</a></li>
    44. 

  44.           <li><a href="#convertibility">Convertibility to the underlying types</a></li>
    45. 

  45.           <li><a href="#modifiers">Modifiers</a></li>
    46. 

  46.           <li><a href="#comparison">Comparison operators</a></li>
    47. 

  47.           <li><a href="#specialized">Specialized algorithms</a></li>
    48. 

  48.           <li><a href="#hash">Hash support</a></li>
    49. 

  49.           <li><a href="#config_macros">Configuration macros</a></li>
    50. 

  50.         </ul>
    51. 

  51.       </li>
    52. 

  52.     </ul>
    53. 

  53.   </li>
    54. 

  54.   <li><a href="#serialize_synopsis">Header
    55. 

  55.     <code>"boost/flyweight/serialize.hpp"</code> synopsis</a>
    56. 

  56.     <ul>
    57. 

  57.       <li><a href="#serialization">Serialization</a></li>
    58. 

  58.     </ul>
    59. 

  59.   </li>
    60. 

  60. </ul>
    61. 

  61. 

  62. <h2>
    63. 

  63. <a name="flyweight_fwd_synopsis">Header
    64. 

  64. <a href="../../../../boost/flyweight/flyweight_fwd.hpp"><code>"boost/flyweight/flyweight_fwd.hpp"</code></a>
    65. 

  65. synopsis</a>
    66. 

  66. </h2>
    67. 

  67. 

  68. <blockquote><pre>
    69. 

  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. 

  70. <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>iosfwd</span><span class=special>&gt;</span>
    71. 

  71. 

  72. <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
    73. 

  73.   
    74. 

  74. <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
    75. 

  75. 

  76. <span class=keyword>template</span><span class=special>&lt;</span>
    77. 

  77.   <span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span>
    78. 

  78.   <span class=keyword>typename</span> <span class=identifier>Arg1</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
    79. 

  79.   <span class=keyword>typename</span> <span class=identifier>Arg2</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
    80. 

  80.   <span class=keyword>typename</span> <span class=identifier>Arg3</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
    81. 

  81.   <span class=keyword>typename</span> <span class=identifier>Arg4</span><span class=special>=</span><b>implementation defined</b><span class=special>,</span>
    82. 

  82.   <span class=keyword>typename</span> <span class=identifier>Arg5</span><span class=special>=</span><b>implementation defined</b>
    83. 

  83. <span class=special>&gt;</span>
    84. 

  84. <span class=keyword>class</span> <span class=identifier>flyweight</span><span class=special>;</span>
    85. 

  85. 

  86. <span class=comment>// comparison:
    87. 

  87. 

  88. // <b>OP</b> is any of ==,&lt;,!=,&gt;,&gt;=,&lt;=</span>
    89. 

  89. 

  90. <span class=keyword>template</span><span class=special>&lt;</span>
    91. 

  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. 

  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. 

  93. <span class=special>&gt;</span>
    94. 

  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. 

  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. 

  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. 

  97. 

  98. <span class=keyword>template</span><span class=special>&lt;</span>
    99. 

  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. 

  100.   <span class=keyword>typename</span> <span class=identifier>T2</span>
    101. 

  101. <span class=special>&gt;</span>
    102. 

  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. 

  103. 

  104. <span class=keyword>template</span><span class=special>&lt;</span>
    105. 

  105.   <span class=keyword>typename</span> <span class=identifier>T1</span><span class=special>,</span>
    106. 

  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. 

  107. <span class=special>&gt;</span>
    108. 

  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. 

  109. 

  110. <span class=comment>// specialized algorithms:</span>
    111. 

  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. 

  113. <span class=keyword>inline</span> <span class=keyword>void</span> <span class=identifier>swap</span><span class=special>(</span>
    114. 

  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. 

  115. 

  116. <span class=keyword>template</span><span class=special>&lt;</span>
    117. 

  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. 

  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. 

  119. <span class=special>&gt;</span>
    120. 

  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. 

  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. 

  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. 

  123. 

  124. <span class=keyword>template</span><span class=special>&lt;</span>
    125. 

  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. 

  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. 

  127. <span class=special>&gt;</span>
    128. 

  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. 

  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. 

  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. 

  131. 

  132. <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
    133. 

  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. 

  135. 

  136. <span class=special>}</span> <span class=comment>// namespace boost</span>
    137. 

  137. 

  138. <span class=comment>// hash support:</span>
    139. 

  139. 

  140. <span class=keyword>namespace</span> <span class=identifier>std</span><span class=special>{</span>
    141. 

  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. 

  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. 

  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. 

  145. 

  146. <span class=special>}</span> <span class=comment>// namespace std</span> 
    147. 

  147. 

  148. <span class=keyword>namespace</span> <span class=identifier>boost</span><span class=special>{</span>
    149. 

  149. <span class=keyword>namespace</span> <span class=identifier>flyweights</span><span class=special>{</span>
    150. 

  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. 

  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. 

  153. 

  154. <span class=special>}</span> <span class=comment>// namespace boost::flyweights</span>
    155. 

  155. <span class=special>}</span> <span class=comment>// namespace boost</span>
    156. 

  156. </pre></blockquote>
    157. 

  157. 

  158. <p>
    159. 

  159. <code>flyweight_fwd.hpp</code> forward declares the class template
    160. 

  160. <a href="#flyweight"><code>flyweight</code></a> and its associated global functions and class template specializations.
    161. 

  161. </p>
    162. 

  162. 

  163. <h2>
    164. 

  164. <a name="synopsis">Header
    165. 

  165. <a href="../../../../boost/flyweight/flyweight.hpp"><code>"boost/flyweight/flyweight.hpp"</code></a>
    166. 

  166. synopsis</a>
    167. 

  167. </h2>
    168. 

  168. 

  169. <h3><a name="flyweight">
    170. 

  170. Class template <code>flyweight</code>
    171. 

  171. </a></h3>
    172. 

  172. 

  173. <p>
    174. 

  174. Objects of type <code>flyweight&lt;...&gt;</code> provide access to immutable
    175. 

  175. values of type <code>flyweight&lt;...&gt;::value_type</code>, with the following advantages over using
    176. 

  176. plain <code>value_type</code> objects:
    177. 

  177. <ul>
    178. 

  178.   <li>Flyweight objects with equivalent value share the same representation
    179. 

  179.     (the associated <code>value_type</code> object).
    180. 

  180.   </li>
    181. 

  181.   <li>The size of flyweights is typically that of a pointer, which is in general
    182. 

  182.     smaller than <code>sizeof(value_type)</code>.
    183. 

  183.   </li>
    184. 

  184. </ul>
    185. 

  185. 

  186. So, if the level of redundancy (ratio of total objects to different values)
    187. 

  187. is high enough, substituting a suitable instantiation of <code>flyweight</code>
    188. 

  188. for <code>value_type</code> results in a reduction in memory usage.
    189. 

  189. </p>
    190. 

  190. 

  191. <p>
    192. 

  192. <code>flyweight</code> is parameterized according to some aspects:
    193. 

  193. <ul>
    194. 

  194.   <li>Types <code>key_value</code> and <code>value_type</code>
    195. 

  195.     (possibly equal), where <code>key_type</code> serves as a
    196. 

  196.     key type to lookup and construct internal shared instances of
    197. 

  197.     objects of <code>value_type</code>.
    198. 

  198.   </li>
    199. 

  199.   <li>An optional <a href="tags.html#tag">tag</a> type meant to syntactically
    200. 

  200.      differentiate between otherwise identical instantiations.
    201. 

  201.   </li>
    202. 

  202.   <li>The <a href="factories.html#factory">factory class</a> used to store
    203. 

  203.     and retrieve the shared value objects.
    204. 

  204.   </li>
    205. 

  205.   <li>The type of <a href="holders.html#holder">holder</a> used to
    206. 

  206.     instantiate the flyweight factory and a mutex object, both of
    207. 

  207.     which are unique to each specialization of the <code>flyweight</code>
    208. 

  208.     class template.
    209. 

  209.   </li>
    210. 

  210.   <li>A <a href="locking.html#locking">locking policy</a> determining
    211. 

  211.     the synchronization mechanisms for internal access to shared resources.
    212. 

  212.   </li>
    213. 

  213.   <li>A <a href="tracking.html#tracking">tracking policy</a> which controls
    214. 

  214.    how values are treated when all their associated flyweight objects are
    215. 

  215.    destroyed.
    216. 

  216.   </li>
    217. 

  217. </ul>
    218. 

  218. These aspects impact the internal structure and behavior
    219. 

  219. of the <code>flyweight</code> instantiation in the following manner:
    220. 

  220. <ul>
    221. 

  221.   <li>Each instantation of <code>flyweight</code> internally owns
    222. 

  222.     a unique factory object and a unique synchronization
    223. 

  223.     <a href="locking.html#preliminary">mutex</a> object, both of which
    224. 

  224.     are created through the use of an associated holder type.
    225. 

  225.   </li>
    226. 

  226.   <li>The flyweight factory stores elements of an undisclosed type
    227. 

  227.     <code>Entry</code> that is implicitly convertible to
    228. 

  228.     <code>const key_type&amp;</code> and also stores a subobject of
    229. 

  229.     <code>value_type</code>. Every flyweight object is associated
    230. 

  230.     to a <code>value_type</code> subobject of some <code>Entry</code>
    231. 

  231.     stored in the factory.
    232. 

  232.   </li>
    233. 

  233.   <li>The associated mutex object is used to protect all invocations
    234. 

  234.     to the insertion and deletion functions of the internal flyweight
    235. 

  235.     factory.
    236. 

  236.   </li>
    237. 

  237.   <li>Each flyweight object internally stores a value of some
    238. 

  238.     undisclosed type <code>Handle</code>. <code>Handle</code> and
    239. 

  239.     the <code>Entry</code> type referred to above are obtained
    240. 

  240.     from invocations to the associated tracking policy, in the
    241. 

  241.     manner described for this concept.
    242. 

  242.   </li>
    243. 

  243. </ul>
    244. 

  244. In what follows, we implicitly assume that <code>key_type</code> equivalence
    245. 

  245. refers to the equivalence relationship induced by the factory class used.
    246. 

  246. Also, two values of <code>value_type</code> are considered equivalent
    247. 

  247. if they are constructed from equivalent keys, or are copies of
    248. 

  248. objects constructed from equivalent keys.
    249. 

  249. </p>
    250. 

  250. 

  251. <blockquote><pre>
    252. 

  252. <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>initializer_list</span><span class=special>&gt;</span>
    253. 

  253. 

  254. <span class=keyword>template</span><span class=special>&lt;</span>
    255. 

  255.   <span class=keyword>typename</span> <span class=identifier>T</span><span class=special>,</span>
    256. 

  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. 

  257. <span class=special>&gt;</span>
    258. 

  258. <span class=keyword>class</span> <span class=identifier>flyweight</span>
    259. 

  259. <span class=special>{</span>
    260. 

  260. <span class=keyword>public</span><span class=special>:</span>
    261. 

  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. 

  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. 

  263. 

  264.   <span class=comment>// static data initialization:</span>
    265. 

  265. 

  266.   <span class=keyword>static</span> <span class=keyword>bool</span> <span class=identifier>init</span><span class=special>();</span>
    267. 

  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. 

  268.     
    269. 

  269.   <span class=comment>// construct/copy/destroy:</span>
    270. 

  270.   
    271. 

  271.   <span class=identifier>flyweight</span><span class=special>();</span>
    272. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  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. 

  296. 

  297.   <span class=comment>// convertibility to underlying type:</span>
    298. 

  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. 

  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. 

  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. 

  302. 

  303.   <span class=comment>// modifiers:</span>
    304. 

  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. 

  306. <span class=special>};</span>
    307. 

  307. </pre></blockquote>
    308. 

  308. 

  309. <h4><a name="instantiation_types">Instantiation types</a></h4>
    310. 

  310. 

  311. <p>
    312. 

  312. <code>T</code> can be either:
    313. 

  313. <ul>
    314. 

  314.   <li>An arbitrary type,</li>
    315. 

  315.   <li>a type of the form 
    316. 

  316.     <a href="key_value.html#key_value_construct"><code>key_value&lt;Key,Value[,KeyFromValue]&gt;</code></a>.</li>
    317. 

  317. </ul>
    318. 

  318. In the first case, the nested types <code>key_type</code> and <code>value_type</code>
    319. 

  319. are both equal to <code>T</code>. In the second case, <code>key_type</code>=<code>Key</code>,
    320. 

  320. <code>value_type</code>=<code>Value</code>; we say then that the instantiation
    321. 

  321. of <code>flyweight</code> is a <i>key-value</i> flyweight.
    322. 

  322. <code>value_type</code> is the type of the values flyweight objects give access to,
    323. 

  323. while value lookup is based on associated <code>key_type</code> values.
    324. 

  324. <code>key_value</code> must be
    325. 

  325. <a href="https://boost.org/sgi/stl/Assignable.html"><code>Assignable</code></a>
    326. 

  326. and <code>value_type</code> must be constructible from <code>key_type</code>;
    327. 

  327. additionally, <code>key_value</code> must
    328. 

  328. conform to any extra requirements imposed by the type of factory used.
    329. 

  329. For key-value flyweights, it is guaranteed that the creation or assignment of a flyweight
    330. 

  330. object results in at most one construction (or copy construction in some
    331. 

  331. particular cases) of an object
    332. 

  332. of <code>value_type</code>, and this construction only occurs in the case that no
    333. 

  333. equivalent value existed previously in the flyweight factory.
    334. 

  334. </p>
    335. 

  335. 

  336. <p>
    337. 

  337. The types <code>Arg1</code>, ... , <code>Arg5</code>, if provided, must be any
    338. 

  338. of the following, in no particular order:
    339. 

  339. <ul>
    340. 

  340.   <li>A <a href="tags.html#tag">tag</a>,</li>
    341. 

  341.   <li>a <a href="factories.html#factory">factory specifier</a>,</li>
    342. 

  342.   <li>a <a href="holders.html#holder">holder specifier</a>,</li>
    343. 

  343.   <li>a <a href="locking.html#locking">locking policy</a>,</li>
    344. 

  344.   <li>a <a href="tracking.html#tracking">tracking policy</a>.</li>
    345. 

  345. </ul>
    346. 

  346. No aspect can be specified twice. Each internal component of the
    347. 

  347. <code>flyweight</code> instantiation is obtained through use of the
    348. 

  348. corresponding specifier; for instance, the factory results from a
    349. 

  349. certain (MPL) invocation of the given factory specifier, the internal
    350. 

  350. mutex from the given locking policy, etc.
    351. 

  351. The default configuration arguments are:
    352. 

  352. <ul>
    353. 

  353.   <li>No tagging,</li>
    354. 

  354.   <li><a href="factories.html#hashed_factory"><code>hashed_factory&lt;&gt;</code></a>,</li>
    355. 

  355.   <li><a href="holders.html#static_holder"><code>static_holder</code></a>,</li>
    356. 

  356.   <li><a href="locking.html#simple_locking"><code>simple_locking</code></a>,</li>
    357. 

  357.   <li><a href="tracking.html#refcounted"><code>refcounted</code></a> tracking policy.</li>
    358. 

  358. </ul>
    359. 

  359. </p>
    360. 

  360. 

  361. <h4><a name="static_init">Static data initialization</a></h4>
    362. 

  362. 

  363. <p>
    364. 

  364. The static data internal to a given <code>flyweight</code> instantiation
    365. 

  365. (factory instance, etc.) is constructed during the dynamic initialization
    366. 

  366. phase of the program and always before the first program-wide use of the
    367. 

  367. instantiated class. The following utilities can be
    368. 

  368. used when more control about the moment of construction is required.
    369. 

  369. </p>
    370. 

  370. 

  371. <code>static bool init();</code>
    372. 

  372. 

  373. <blockquote>
    374. 

  374. <b>Effects:</b> After execution of this function the static data associated
    375. 

  375. to the instantiation of <code>flyweight</code> is guaranteed to be
    376. 

  376. constructed.<br>
    377. 

  377. <b>Note:</b> Concurrent execution of this function is not thread safe.
    378. 

  378. </blockquote>
    379. 

  379. 

  380. <code>initializer::initializer();</code>
    381. 

  381. 

  382. <blockquote>
    383. 

  383. <b>Effects:</b> Executes <code>init()</code>.
    384. 

  384. </blockquote>
    385. 

  385. 

  386. <h4><a name="constructors">Constructors, copy and assignment</a></h4>
    387. 

  387. 

  388. <code>flyweight();</code>
    389. 

  389. 

  390. <blockquote>
    391. 

  391. <b>Effects:</b> Constructs a <code>flyweight</code> object with the value
    392. 

  392. <code>value_type(key_type())</code>
    393. 

  393. if <code>flyweight</code> is key-value
    394. 

  394. or <code>value_type()</code>
    395. 

  395. otherwise.
    396. 

  396. </blockquote>
    397. 

  397. 

  398. <a name="fwd_ctor">
    399. 

  399. <code>template&lt;typename... Args&gt;<br>
    400. 

  400. explicit flyweight(Args&amp;&amp;... args);</code></a>
    401. 

  401. 

  402. <blockquote>
    403. 

  403. <b>Effects:</b> Constructs a <code>flyweight</code> object with the value
    404. 

  404. <code>value_type(key_type(std::forward&lt;Args&gt;(args)...))</code>
    405. 

  405. if <code>flyweight</code> is key-value
    406. 

  406. or <code>value_type(std::forward&lt;Args&gt;(args)...)</code>
    407. 

  407. otherwise.<br>
    408. 

  408. <b>Note:</b> In compilers without variadic template support, the implementation
    409. 

  409. replaces this constructor with a number of overloads accepting
    410. 

  410. any combination of const/non-const lvalue/rvalue reference arguments
    411. 

  411. up to a maximum number that 
    412. 

  412. can be globally <a href="#limit_num_ctor_args">configured</a> by the user.
    413. 

  413. </blockquote>
    414. 

  414. 

  415. <code>template&lt;typename V&gt;<br>
    416. 

  416. flyweight(std::initializer_list&lt;V&gt; list);</code>
    417. 

  417. 

  418. <blockquote>
    419. 

  419. <b>Effects:</b> Constructs a <code>flyweight</code> object with the value
    420. 

  420. <code>value_type(key_type(list))</code> if <code>flyweight</code> is key-value
    421. 

  421. or <code>value_type(list)</code> otherwise.<br>
    422. 

  422. <b>Note:</b> The specialization for a particular <code>std::initializer_list&lt;V'&gt;</code>
    423. 

  423. of this member function template is not available unless
    424. 

  424. <code>key_type</code> is constructible from
    425. 

  425. <code>std::initializer_list&lt;V'&gt;</code>.
    426. 

  426. </blockquote>
    427. 

  427. 

  428. <code>flyweight(const flyweight&amp; x);<br>
    429. 

  429. flyweight(flyweight&amp; x);<br>
    430. 

  430. flyweight(const flyweight&amp;&amp; x);<br>
    431. 

  431. flyweight(flyweight&amp;&amp; x);</code>
    432. 

  432. 

  433. <blockquote>
    434. 

  434. <b>Effects:</b> Constructs a <code>flyweight</code> object associated to
    435. 

  435. the same value as <code>x</code>.<br>
    436. 

  436. <b>Exception safety:</b> <code>nothrow</code>.
    437. 

  437. </blockquote>
    438. 

  438. 

  439. <code>explicit flyweight(const value_type&amp; x);<br>
    440. 

  440. explicit flyweight(value_type&amp; x);<br>
    441. 

  441. explicit flyweight(const value_type&amp;&amp; x);<br>
    442. 

  442. explicit flyweight(value_type&amp;&amp; x);</code>
    443. 

  443. 

  444. <blockquote>
    445. 

  445. <b>Requires:</b> If <code>flyweight</code> is key-value,
    446. 

  446. <code>value_type</code> is
    447. 

  447. <a href="https://boost.org/sgi/stl/Assignable.html"><code>Assignable</code></a>
    448. 

  448. and the
    449. 

  449. <a href="key_value.html#key_extractor"><code>Key Extractor</code></a>
    450. 

  450. <code>KeyFromValue</code> must have been supplied as part of the
    451. 

  451. <code>key_value&lt;&gt;</code> construct.<br>
    452. 

  452. <b>Effects:</b> Constructs a <code>flyweight</code> associated to a
    453. 

  453. copy of <code>x</code> or with a <code>value_type</code> constructed
    454. 

  454. from a key equivalent to that associated to <code>x</code>. For non-key-value
    455. 

  455. flyweights, <code>x</code> is its own key; for key-value flyweights,
    456. 

  456. the key is extracted through use of an object of type <code>KeyFromValue</code>.<br>
    457. 

  457. </blockquote>
    458. 

  458. 

  459. <code>template&lt;typename V&gt;<br>
    460. 

  460. flyweight&amp; operator=(std::initializer_list&lt;V&gt; list);</code>
    461. 

  461. 

  462. <blockquote>
    463. 

  463. <b>Effects:</b> <code>*this=flyweight(list)</code>.<br>
    464. 

  464. <b>Returns:</b> <code>*this</code>.<br>
    465. 

  465. <b>Note:</b> The specialization for a particular <code>std::initializer_list&lt;V'&gt;</code>
    466. 

  466. of this member function template is not available unless
    467. 

  467. <code>key_type</code> is constructible from
    468. 

  468. <code>std::initializer_list&lt;V'&gt;</code>.
    469. 

  469. </blockquote>
    470. 

  470. 

  471. <code>flyweight&amp; operator=(const flyweight&amp; x);</code>
    472. 

  472. 

  473. <blockquote>
    474. 

  474. <b>Effects:</b> Associates the <code>flyweight</code> object with the same value
    475. 

  475. as <code>x</code>.<br>
    476. 

  476. <b>Returns:</b> <code>*this</code>.<br>
    477. 

  477. <b>Exception safety:</b> <code>nothrow</code>.
    478. 

  478. </blockquote>
    479. 

  479. 

  480. <code>flyweight&amp; operator=(const value_type&amp; x);<br>
    481. 

  481. flyweight&amp; operator=(value_type&amp;&amp; x);</code>
    482. 

  482. 

  483. <blockquote>
    484. 

  484. <b>Effects:</b> <code>*this=flyweight(x)</code> (first overload),
    485. 

  485. <code>*this=flyweight(std::move(x))</code> (second overload).<br>
    486. 

  486. <b>Returns:</b> <code>*this</code>.<br>
    487. 

  487. </blockquote>
    488. 

  488. 

  489. <h4><a name="convertibility">Convertibility to the underlying types</a></h4>
    490. 

  490. 

  491. <code>const key_type&amp; get_key()const;</code>
    492. 

  492. 

  493. <blockquote>
    494. 

  494. <b>Returns:</b> A copy of the key used to construct the
    495. 

  495. <code>value_type</code> associated to the <code>flyweight</code>
    496. 

  496. object.<br>
    497. 

  497. <b>Exception safety:</b> If <code>flyweight</code> is not key-value or
    498. 

  498. if <code>KeyFromValue</code> was not provided, <code>nothrow</code>.
    499. 

  499. </blockquote>
    500. 

  500. 

  501. <code>const value_type&amp; get()const;<br>
    502. 

  502. 	operator const value_type&amp;()const;</code>
    503. 

  503. 

  504. <blockquote>
    505. 

  505. <b>Returns:</b> The value associated to the <code>flyweight</code>
    506. 

  506. object.<br>
    507. 

  507. <b>Exception safety:</b> <code>nothrow</code>.
    508. 

  508. </blockquote>
    509. 

  509. 

  510. <h4><a name="modifiers">Modifiers</a></h4>
    511. 

  511. 

  512. <code>void swap(flyweight&amp; x);</code>
    513. 

  513. 

  514. <blockquote>
    515. 

  515. <b>Effects:</b> Swaps the associations to <code>value_type</code>s each
    516. 

  516. flyweight object has. No swapping of <code>key_type</code> or
    517. 

  517. <code>value_type</code> objects is done.<br>
    518. 

  518. <b>Exception safety:</b> <code>nothrow</code>.
    519. 

  519. </blockquote>
    520. 

  520. 

  521. <h4><a name="comparison">Comparison operators</a></h4>
    522. 

  522. 

  523. <code>template&lt;<br>
    524. 

  524. &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
    525. 

  525. &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
    526. 

  526. &gt;<br>
    527. 

  527. bool operator ==(<br>
    528. 

  528. &nbsp;&nbsp;const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,<br>
    529. 

  529. &nbsp;&nbsp;const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
    530. 

  530. 

  531. <blockquote>
    532. 

  532. <b>Returns:</b> If <code>x</code> and <code>y</code> are of the same type, returns
    533. 

  533. <code>true</code> if and only if they are associated to the same value; if
    534. 

  534. <code>x</code> and <code>y</code> have different types, returns
    535. 

  535. <code>x.get()==y.get()</code>.<br>
    536. 

  536. <b>Exception safety:</b> If <code>x</code> and <code>y</code> are of the same type,
    537. 

  537. <code>nothrow</code>.
    538. 

  538. </blockquote>
    539. 

  539. 

  540. <code>template&lt;<br>
    541. 

  541. &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
    542. 

  542. &nbsp;&nbsp;typename T2<br>
    543. 

  543. &gt;<br>
    544. 

  544. bool operator ==(const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,const T2&amp; y);</code>
    545. 

  545. 

  546. <blockquote>
    547. 

  547. <b>Returns:</b> <code>x.get()==y</code>.
    548. 

  548. </blockquote>
    549. 

  549. 

  550. <code>template&lt;<br>
    551. 

  551. &nbsp;&nbsp;typename T1,<br>
    552. 

  552. &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
    553. 

  553. &gt;<br>
    554. 

  554. bool operator ==(const T1&amp; x,const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
    555. 

  555. 

  556. <blockquote>
    557. 

  557. <b>Returns:</b> <code>x==y.get()</code>.
    558. 

  558. </blockquote>
    559. 

  559. 

  560. <code>template&lt;<br>
    561. 

  561. &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
    562. 

  562. &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
    563. 

  563. &gt;<br>
    564. 

  564. bool operator &lt;(<br>
    565. 

  565. &nbsp;&nbsp;const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,<br>
    566. 

  566. &nbsp;&nbsp;const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
    567. 

  567. 

  568. <blockquote>
    569. 

  569. <b>Returns:</b> <code>x.get()&lt;y.get()</code>.
    570. 

  570. </blockquote>
    571. 

  571. 

  572. <code>template&lt;<br>
    573. 

  573. &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
    574. 

  574. &nbsp;&nbsp;typename T2<br>
    575. 

  575. &gt;<br>
    576. 

  576. bool operator &lt;(const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,const T2&amp; y);</code>
    577. 

  577. 

  578. <blockquote>
    579. 

  579. <b>Returns:</b> <code>x.get()&lt;y</code>.
    580. 

  580. </blockquote>
    581. 

  581. 

  582. <code>template&lt;<br>
    583. 

  583. &nbsp;&nbsp;typename T1,<br>
    584. 

  584. &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
    585. 

  585. &gt;<br>
    586. 

  586. bool operator &lt;(const T1&amp; x,const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
    587. 

  587. 

  588. <blockquote>
    589. 

  589. <b>Returns:</b> <code>x&lt;y.get()</code>.
    590. 

  590. </blockquote>
    591. 

  591. 

  592. 

  593. <code>template&lt;<br>
    594. 

  594. &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
    595. 

  595. &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
    596. 

  596. &gt;<br>
    597. 

  597. bool operator <b><i>OP</i></b>(<br>
    598. 

  598. &nbsp;&nbsp;const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,<br>
    599. 

  599. &nbsp;&nbsp;const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);<br>
    600. 

  600. template&lt;<br>
    601. 

  601. &nbsp;&nbsp;typename T1,typename Arg11,...,typename Arg15,<br>
    602. 

  602. &nbsp;&nbsp;typename T2<br>
    603. 

  603. &gt;<br>
    604. 

  604. bool operator <b><i>OP</i></b>(const flyweight&lt;T1,Arg11,...,Arg15&gt;&amp; x,const T2&amp; y);</br>
    605. 

  605. template&lt;<br>
    606. 

  606. &nbsp;&nbsp;typename T1,<br>
    607. 

  607. &nbsp;&nbsp;typename T2,typename Arg21,...,typename Arg25<br>
    608. 

  608. &gt;<br>
    609. 

  609. bool operator <b><i>OP</i></b>(const T1&amp; x,const flyweight&lt;T2,Arg21,...,Arg25&gt;&amp; y);</code>
    610. 

  610. 

  611. <p>
    612. 

  612. (<code><b><i>OP</i></b></code> is any of <code>!=</code>, <code>></code>,
    613. 

  613. <code>>=</code>, <code>&lt;=</code>.)
    614. 

  614. </p>
    615. 

  615. 

  616. <blockquote>
    617. 

  617. <b>Returns:</b> <code>true</code> if and only if
    618. 

  618. <blockquote>
    619. 

  619. <code>!(x==y)</code> (<code><b><i>OP</i></b></code> is <code>!=</code>),<br>
    620. 

  620. <code>&nbsp;&nbsp;y&lt;&nbsp;x&nbsp;</code> (<code><b><i>OP</i></b></code> is <code>>&nbsp;</code>),<br>
    621. 

  621. <code>!(x&lt;&nbsp;y)</code> (<code><b><i>OP</i></b></code> is <code>>=</code>),<br>
    622. 

  622. <code>!(y&lt;&nbsp;x)</code> (<code><b><i>OP</i></b></code> is <code>&lt;=</code>).
    623. 

  623. </blockquote>
    624. 

  624. </blockquote>
    625. 

  625. 

  626. <h4><a name="specialized">Specialized algorithms</a></h4>
    627. 

  627. 

  628. <code>template&lt;typename T,typename Arg1,...,typename Arg5&gt;<br>
    629. 

  629. inline void swap(<br>
    630. 

  630. &nbsp;&nbsp;flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x,flyweight&lt;T,Arg1,...,Arg5&gt;&amp; y);</code>
    631. 

  631. 

  632. <blockquote>
    633. 

  633. <b>Effects:</b> <code>x.swap(y)</code>.
    634. 

  634. </blockquote>
    635. 

  635. 

  636. <code>template&lt;<br>
    637. 

  637. &nbsp;&nbsp;typename ElemType,typename Traits, <br>
    638. 

  638. &nbsp;&nbsp;typename T,typename Arg1,...,typename Arg5<br>
    639. 

  639. &gt;<br>
    640. 

  640. inline std::basic_ostream&lt;ElemType,Traits&gt;&amp; operator&lt;&lt;(<br>
    641. 

  641. &nbsp;&nbsp;std::basic_ostream&lt;ElemType,Traits&gt;&amp; out,<br>
    642. 

  642. &nbsp;&nbsp;const flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x);</code>
    643. 

  643. 

  644. <blockquote>
    645. 

  645. <b>Effects:</b> <code>out&lt;&lt;x.get()</code>.<br>
    646. 

  646. <b>Returns:</b> <code>out</code>.
    647. 

  647. </blockquote>
    648. 

  648. 

  649. <code>template&lt;<br>
    650. 

  650. &nbsp;&nbsp;typename ElemType,typename Traits, <br>
    651. 

  651. &nbsp;&nbsp;typename T,typename Arg1,...,typename Arg5<br>
    652. 

  652. &gt;<br>
    653. 

  653. inline std::basic_ostream&lt;ElemType,Traits&gt;&amp; operator&gt;&gt;(<br>
    654. 

  654. &nbsp;&nbsp;std::basic_istream&lt;ElemType,Traits&gt;&amp; in,<br>
    655. 

  655. &nbsp;&nbsp;flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x);</code>
    656. 

  656. 

  657. <blockquote>
    658. 

  658. <b>Requires:</b> If <code>flyweight</code> is key-value,
    659. 

  659. <code>value_type</code> is
    660. 

  660. <a href="https://boost.org/sgi/stl/Assignable.html"><code>Assignable</code></a>
    661. 

  661. and the
    662. 

  662. <a href="key_value.html#key_extractor"><code>Key Extractor</code></a>
    663. 

  663. <code>KeyFromValue</code> must have been supplied as part of the
    664. 

  664. <code>key_value&lt;&gt;</code> construct.<br>
    665. 

  665. <b>Effects:</b> Reads an object of type <code>value_type</code> from <code>in</code>
    666. 

  666. and assigns it to <code>x</code>.<br>
    667. 

  667. <b>Returns:</b> <code>in</code>.
    668. 

  668. </blockquote>
    669. 

  669. 

  670. <h4><a name="hash">Hash support</a></h4>
    671. 

  671. 

  672. <p>
    673. 

  673. Support is provided for hashing <code>flyweight</code>s both with <code>std::hash</code> and
    674. 

  674. <a href="../../../../doc/html/hash.html"><code>boost::hash</code></a>. In either case, the calculation
    675. 

  675. does not involve hashing the associated <code>value_type</code> objects themselves; so, it is
    676. 

  676. immaterial whether <code>value_type</code> is hashable or not.
    677. 

  677. The results given by <code>std::hash</code> and <code>boost::hash</code> for the same
    678. 

  678. <code>flyweight</code> object will usually differ.<br />
    679. 

  679. <b>Note:</b> Hash support can be <a href="#disable_hash_support">disabled</a> to solve
    680. 

  680. clashes with code where this has already been defined by the user.
    681. 

  681. </p>
    682. 

  682. 

  683. <code>namespace std{<br>
    684. 

  684. template&lt;typename T,typename Arg1,...,typename Arg5&gt;<br>
    685. 

  685. struct hash&lt;boost::flyweight&lt;T,Arg1,...,Arg5&gt; &gt;;<br>
    686. 

  686. }</code>
    687. 

  687. 

  688. <blockquote>
    689. 

  689. This template specialization meets the requirements of class template <code>std::hash</code> in <b>[unord.hash]</b>.
    690. 

  690. No exception is thrown when invoking instances of this specialization.
    691. 

  691. </blockquote>
    692. 

  692. 

  693. <code>template&lt;typename T,typename Arg1,...,typename Arg5&gt;<br>
    694. 

  694. inline std::size_t hash_value(const flyweight&lt;T,Arg1,...,Arg5&gt;&amp; x);</code>
    695. 

  695. 

  696. <blockquote>
    697. 

  697. <b>Returns:</b> A hash value for <code>x</code> to be used by
    698. 

  698. <a href="../../../../doc/html/hash/custom.html">Boost.Hash</a>.<br>
    699. 

  699. <b>Exception safety:</b> <code>nothrow</code>.
    700. 

  700. </blockquote>
    701. 

  701. 

  702. <h4><a name="config_macros">Configuration macros</a></h4>
    703. 

  703. 

  704. <a name="limit_num_ctor_args">
    705. 

  705. <code>BOOST_FLYWEIGHT_LIMIT_PERFECT_FWD_ARGS</code></a>
    706. 

  706. 

  707. <blockquote>
    708. 

  708. In compilers without variadic template support,
    709. 

  709. globally define this macro to set the maximum number of
    710. 

  710. arguments accepted by <code>flyweight</code>
    711. 

  711. <a href="#fwd_ctor">forwarding constructor</a>, which by default
    712. 

  712. is 5.
    713. 

  713. </blockquote>
    714. 

  714. 

  715. <a name="disable_hash_support">
    716. 

  716. <code>BOOST_FLYWEIGHT_DISABLE_HASH_SUPPORT</code></a>
    717. 

  717. 

  718. <blockquote>
    719. 

  719. If defined, hash support is not provided. This can be useful to cope
    720. 

  720. with legacy code where general <code>flyweight</code> hashing has already been
    721. 

  721. defined by the user.
    722. 

  722. </blockquote>
    723. 

  723. 

  724. <h2>
    725. 

  725. <a name="serialize_synopsis">Header
    726. 

  726. </a><a href="../../../../boost/flyweight/serialize.hpp"><code>"boost/flyweight/serialize.hpp"</code></a>
    727. 

  727. synopsis
    728. 

  728. </h2>
    729. 

  729. 

  730. <p>
    731. 

  731. <code>serialize.hpp</code> includes the necessary functionality for interoperability
    732. 

  732. of <code>flyweight</code> with
    733. 

  733. <a href="../../../serialization/index.html">Boost.Serialization</a>.
    734. 

  734. </p>
    735. 

  735. 

  736. <h3><a name="serialization">Serialization</a></h3>
    737. 

  737. 

  738. <p>
    739. 

  739. <code>flyweight</code>s can be archived and retrieved by means of
    740. 

  740. <a href="../../../serialization/index.html">Boost.Serialization</a>. Regular as well
    741. 

  741. as XML archives are supported.
    742. 

  742. Serialization is done in an efficient manner so that saving equivalent <code>flyweight</code>s
    743. 

  743. result in their common <code>key_type</code> value being stored only once, regardless
    744. 

  744. of whether <code>key_type</code> is 
    745. 

  745. <a href="../../../serialization/doc/traits.html#tracking">tracked</a> by
    746. 

  746. Boost.Serialization or not.
    747. 

  747. </p>
    748. 

  748. 

  749. Operation: saving of a <code>flyweight</code> object <code>x</code> to an
    750. 

  750. output archive (XML archive) <code>ar</code>.
    751. 

  751. 

  752. <blockquote>
    753. 

  753. <b>Requires:</b> <code>key_type</code> is serializable (XML-serializable).<br>
    754. 

  754. <b>Effects:</b> The value <code>k=x.get_key()</code> is saved into <code>ar</code> as
    755. 

  755. part of this operation or of a previous saving operation of a <code>flyweight</code>
    756. 

  756. object with the same key.<br>
    757. 

  757. <b>Exception safety:</b> Strong with respect to <code>x</code>. If an exception
    758. 

  758. is thrown, <code>ar</code> may be left in an inconsistent state.
    759. 

  759. </blockquote>
    760. 

  760. 

  761. Operation: loading of a <code>flyweight</code> <code>x'</code> from an
    762. 

  762. input archive (XML archive) <code>ar</code>.
    763. 

  763. 

  764. <blockquote>
    765. 

  765. <b>Requires:</b> <code>key_type</code> is serializable (XML-serializable).<br>
    766. 

  766. <b>Effects:</b> <code>x'</code> is associated to a value constructed from a key
    767. 

  767. equivalent to <code>k'</code>, a restored copy of the value <code>k</code>
    768. 

  768. defined above.<br>
    769. 

  769. <b>Exception safety:</b> Strong with respect to <code>x'</code>. If an exception
    770. 

  770. is thrown, <code>ar</code> may be left in an inconsistent state.
    771. 

  771. </blockquote>
    772. 

  772. 

  773. <hr>
    774. 

  774. 

  775. <div class="prev_link"><a href="index.html"><img src="../prev.gif" alt="Boost.Flyweight reference" border="0"><br>
    776. 

  776. Boost.Flyweight reference
    777. 

  777. </a></div>
    778. 

  778. <div class="up_link"><a href="index.html"><img src="../up.gif" alt="Boost.Flyweight reference" border="0"><br>
    779. 

  779. Boost.Flyweight reference
    780. 

  780. </a></div>
    781. 

  781. <div class="next_link"><a href="key_value.html"><img src="../next.gif" alt="key-value flyweights" border="0"><br>
    782. 

  782. Key-value flyweights
    783. 

  783. </a></div><br clear="all" style="clear: all;">
    784. 

  784. 

  785. <br>
    786. 

  786. 

  787. <p>Revised April 24th 2019</p>
    788. 

  788. 

  789. <p>&copy; Copyright 2006-2019 Joaqu&iacute;n M L&oacute;pez Mu&ntilde;oz.
    790. 

  790. Distributed under the Boost Software 
    791. 

  791. License, Version 1.0. (See accompanying file <a href="../../../../LICENSE_1_0.txt">
    792. 

  792. LICENSE_1_0.txt</a> or copy at <a href="http://www.boost.org/LICENSE_1_0.txt">
    793. 

  793. http://www.boost.org/LICENSE_1_0.txt</a>)
    794. 

  794. </p>
    795. 

  795. 

  796. </body>
    797. 

  797. </html>
    798.