Home Explore Help
Register Sign In
devn00b
/
EQ2EMu
9
3
Fork 0
Files Issues 59
Tree: 206dc6819b
Branches Tags
EQ2EMu
/
EQ2
/
source
/
depends
/
boost_1_72_0
/
libs
/
bimap
/
doc
/
html
/
boost_bimap
/
reference
/
unordered_set_of_reference.html

unordered_set_of_reference.html 116 KB
History Raw

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251 
  1. <html>
    2. 

  2. <head>
    3. 

  3. <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
    4. 

  4. <title>unordered_set_of Reference</title>
    5. 

  5. <link rel="stylesheet" href="../../boostbook.css" type="text/css">
    6. 

  6. <meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
    7. 

  7. <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Bimap">
    8. 

  8. <link rel="up" href="../reference.html" title="Reference">
    9. 

  9. <link rel="prev" href="set_of_reference.html" title="set_of Reference">
    10. 

  10. <link rel="next" href="list_of_reference.html" title="list_of Reference">
    11. 

  11. </head>
    12. 

  12. <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
    13. 

  13. <table cellpadding="2" width="100%"><tr>
    14. 

  14. <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
    15. 

  15. <td align="center"><a href="../../../../../../index.html">Home</a></td>
    16. 

  16. <td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
    17. 

  17. <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
    18. 

  18. <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
    19. 

  19. <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
    20. 

  20. </tr></table>
    21. 

  21. <hr>
    22. 

  22. <div class="spirit-nav">
    23. 

  23. <a accesskey="p" href="set_of_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="list_of_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
    24. 

  24. </div>
    25. 

  25. <div class="section">
    26. 

  26. <div class="titlepage"><div><div><h3 class="title">
    27. 

  27. <a name="boost_bimap.reference.unordered_set_of_reference"></a><a class="link" href="unordered_set_of_reference.html" title="unordered_set_of Reference">unordered_set_of
    28. 

  28.       Reference</a>
    29. 

  29. </h3></div></div></div>
    30. 

  30. <div class="toc"><dl class="toc">
    31. 

  31. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_set_of_hpp__synopsis">Header
    32. 

  32.         "boost/bimap/unordered_set_of.hpp" synopsis</a></span></dt>
    33. 

  33. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_multiset_of_hpp__synopsis">Header
    34. 

  34.         "boost/bimap/unordered_multiset_of.hpp" synopsis</a></span></dt>
    35. 

  35. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.collection_type_specifiers_unordered_set_of_and_unordered_multiset_of">Collection
    36. 

  36.         type specifiers unordered_set_of and unordered_multiset_of</a></span></dt>
    37. 

  37. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views">unordered_[multi]set_of
    38. 

  38.         Views</a></span></dt>
    39. 

  39. <dd><dl>
    40. 

  40. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature">Complexity
    41. 

  41.           signature</a></span></dt>
    42. 

  42. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types">Instantiation
    43. 

  43.           types</a></span></dt>
    44. 

  44. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types">Nested
    45. 

  45.           types</a></span></dt>
    46. 

  46. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment">Constructors,
    47. 

  47.           copy and assignment</a></span></dt>
    48. 

  48. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers">Modifiers</a></span></dt>
    49. 

  49. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup">Lookup</a></span></dt>
    50. 

  50. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only">at(),
    51. 

  51.           info_at() and operator[] - set_of only</a></span></dt>
    52. 

  52. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy">Hash
    53. 

  53.           policy</a></span></dt>
    54. 

  54. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization">Serialization</a></span></dt>
    55. 

  55. </dl></dd>
    56. 

  56. </dl></div>
    57. 

  57. <div class="section">
    58. 

  58. <div class="titlepage"><div><div><h4 class="title">
    59. 

  59. <a name="boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_set_of_hpp__synopsis"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_set_of_hpp__synopsis" title='Header "boost/bimap/unordered_set_of.hpp" synopsis'>Header
    60. 

  60.         "boost/bimap/unordered_set_of.hpp" synopsis</a>
    61. 

  61. </h4></div></div></div>
    62. 

  62. <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
    63. 

  63. <span class="keyword">namespace</span> <span class="identifier">bimaps</span> <span class="special">{</span>
    64. 

  64. 

  65. 

  66. <span class="keyword">template</span>
    67. 

  67. <span class="special">&lt;</span>
    68. 

  68.     <span class="keyword">class</span> <span class="identifier">KeyType</span><span class="special">,</span>
    69. 

  69.     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">KeyType</span> <span class="special">&gt;,</span>
    70. 

  70.     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span> <span class="identifier">KeyType</span> <span class="special">&gt;</span>
    71. 

  71. <span class="special">&gt;</span>
    72. 

  72. <span class="keyword">struct</span> <span class="identifier">unordered_set_of</span><span class="special">;</span>
    73. 

  73. 

  74. 

  75. <span class="keyword">template</span>
    76. 

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

  77.     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">_relation</span> <span class="special">&gt;,</span>
    78. 

  78.     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span> <span class="identifier">_relation</span> <span class="special">&gt;</span>
    79. 

  79. <span class="special">&gt;</span>
    80. 

  80. <span class="keyword">struct</span> <span class="identifier">unordered_set_of_relation</span><span class="special">;</span>
    81. 

  81. 

  82. 

  83. <span class="special">}</span> <span class="comment">// namespace bimap</span>
    84. 

  84. <span class="special">}</span> <span class="comment">// namespace boost</span>
    85. 

  85. </pre>
    86. 

  86. </div>
    87. 

  87. <div class="section">
    88. 

  88. <div class="titlepage"><div><div><h4 class="title">
    89. 

  89. <a name="boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_multiset_of_hpp__synopsis"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.header__boost_bimap_unordered_multiset_of_hpp__synopsis" title='Header "boost/bimap/unordered_multiset_of.hpp" synopsis'>Header
    90. 

  90.         "boost/bimap/unordered_multiset_of.hpp" synopsis</a>
    91. 

  91. </h4></div></div></div>
    92. 

  92. <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
    93. 

  93. <span class="keyword">namespace</span> <span class="identifier">bimaps</span> <span class="special">{</span>
    94. 

  94. 

  95. 

  96. <span class="keyword">template</span>
    97. 

  97. <span class="special">&lt;</span>
    98. 

  98.     <span class="keyword">class</span> <span class="identifier">KeyType</span><span class="special">,</span>
    99. 

  99.     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">KeyType</span> <span class="special">&gt;,</span>
    100. 

  100.     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span> <span class="identifier">KeyType</span> <span class="special">&gt;</span>
    101. 

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

  102. <span class="keyword">struct</span> <span class="identifier">unordered_multiset_of</span><span class="special">;</span>
    103. 

  103. 

  104. 

  105. <span class="keyword">template</span>
    106. 

  106. <span class="special">&lt;</span>
    107. 

  107.     <span class="keyword">class</span> <span class="identifier">HashFunctor</span>   <span class="special">=</span> <span class="identifier">hash</span><span class="special">&lt;</span> <span class="identifier">_relation</span> <span class="special">&gt;,</span>
    108. 

  108.     <span class="keyword">class</span> <span class="identifier">EqualKey</span>      <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">equal_to</span><span class="special">&lt;</span> <span class="identifier">_relation</span> <span class="special">&gt;</span>
    109. 

  109. <span class="special">&gt;</span>
    110. 

  110. <span class="keyword">struct</span> <span class="identifier">unordered_multiset_of_relation</span><span class="special">;</span>
    111. 

  111. 

  112. 

  113. <span class="special">}</span> <span class="comment">// namespace bimap</span>
    114. 

  114. <span class="special">}</span> <span class="comment">// namespace boost</span>
    115. 

  115. </pre>
    116. 

  116. </div>
    117. 

  117. <div class="section">
    118. 

  118. <div class="titlepage"><div><div><h4 class="title">
    119. 

  119. <a name="boost_bimap.reference.unordered_set_of_reference.collection_type_specifiers_unordered_set_of_and_unordered_multiset_of"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.collection_type_specifiers_unordered_set_of_and_unordered_multiset_of" title="Collection type specifiers unordered_set_of and unordered_multiset_of">Collection
    120. 

  120.         type specifiers unordered_set_of and unordered_multiset_of</a>
    121. 

  121. </h4></div></div></div>
    122. 

  122. <p>
    123. 

  123.           These collection types specifiers allow for set views without and with
    124. 

  124.           allowance of duplicate elements, respectively. The syntax of <code class="computeroutput"><span class="identifier">set_of</span></code> and <code class="computeroutput"><span class="identifier">multiset_of</span></code>
    125. 

  125.           coincide, thus we describe them in a grouped manner.
    126. 

  126.         </p>
    127. 

  127. </div>
    128. 

  128. <div class="section">
    129. 

  129. <div class="titlepage"><div><div><h4 class="title">
    130. 

  130. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views" title="unordered_[multi]set_of Views">unordered_[multi]set_of
    131. 

  131.         Views</a>
    132. 

  132. </h4></div></div></div>
    133. 

  133. <div class="toc"><dl class="toc">
    134. 

  134. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature">Complexity
    135. 

  135.           signature</a></span></dt>
    136. 

  136. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types">Instantiation
    137. 

  137.           types</a></span></dt>
    138. 

  138. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types">Nested
    139. 

  139.           types</a></span></dt>
    140. 

  140. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment">Constructors,
    141. 

  141.           copy and assignment</a></span></dt>
    142. 

  142. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers">Modifiers</a></span></dt>
    143. 

  143. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup">Lookup</a></span></dt>
    144. 

  144. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only">at(),
    145. 

  145.           info_at() and operator[] - set_of only</a></span></dt>
    146. 

  146. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy">Hash
    147. 

  147.           policy</a></span></dt>
    148. 

  148. <dt><span class="section"><a href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization">Serialization</a></span></dt>
    149. 

  149. </dl></div>
    150. 

  150. <p>
    151. 

  151.           An unordered_[multi]set_of set view is a tr1::unordered[multi]set signature
    152. 

  152.           compatible interface to the underlying heap of elements contained in a
    153. 

  153.           <code class="computeroutput"><span class="identifier">bimap</span></code>.
    154. 

  154.         </p>
    155. 

  155. <p>
    156. 

  156.           The interface and semantics of <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
    157. 

  157.           views are modeled according to the proposal for unordered associative containers
    158. 

  158.           given in the <a href="http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1836.pdf" target="_top">C++
    159. 

  159.           Standard Library Technical Report</a>, also known as TR1. An <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> view is particularized according
    160. 

  160.           to a given <code class="computeroutput"><span class="identifier">Hash</span></code> function
    161. 

  161.           object which returns hash values for the keys and a binary predicate <code class="computeroutput"><span class="identifier">Pred</span></code> acting as an equivalence relation
    162. 

  162.           on values of Key.
    163. 

  163.         </p>
    164. 

  164. <p>
    165. 

  165.           There are two variants: unordered_set_of, which do not allow duplicate
    166. 

  166.           elements (with respect to its associated comparison predicate) and unordered_multiset_of,
    167. 

  167.           which accept those duplicates. The interface of these two variants is the
    168. 

  168.           same to a great extent, so they are documented together with their differences
    169. 

  169.           explicitly noted when they exist.
    170. 

  170.         </p>
    171. 

  171. <p>
    172. 

  172.           If you look the bimap by a side, you will use a map view and if you looked
    173. 

  173.           it as a whole you will be using a set view.
    174. 

  174.         </p>
    175. 

  175. <p>
    176. 

  176.           Except where noted, <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
    177. 

  177.           views (both unique and non-unique) are models of <code class="literal">Unordered Associative
    178. 

  178.           Container</code>. Validity of iterators and references to elements is
    179. 

  179.           preserved in all cases. Occasionally, the exception safety guarantees provided
    180. 

  180.           are actually stronger than required by the extension draft. We only provide
    181. 

  181.           descriptions of those types and operations that are either not present
    182. 

  182.           in the concepts modeled or do not exactly conform to the requirements for
    183. 

  183.           unordered associative containers.
    184. 

  184.         </p>
    185. 

  185. <pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
    186. 

  186. <span class="keyword">namespace</span> <span class="identifier">bimap</span> <span class="special">{</span>
    187. 

  187. <span class="keyword">namespace</span> <span class="identifier">views</span> <span class="special">{</span>
    188. 

  188. 

  189. <span class="keyword">template</span><span class="special">&lt;</span> <span class="emphasis"><em>-implementation defined parameter list-</em></span> <span class="special">&gt;</span>
    190. 

  190. <span class="keyword">class</span> <span class="emphasis"><em>-implementation defined view name-</em></span>
    191. 

  191. <span class="special">{</span>
    192. 

  192.     <span class="keyword">public</span><span class="special">:</span>
    193. 

  193. 

  194.     <span class="comment">// types</span>
    195. 

  195. 

  196.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">key_type</span><span class="special">;</span>
    197. 

  197.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">value_type</span><span class="special">;</span>
    198. 

  198.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">key_compare</span><span class="special">;</span>
    199. 

  199.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">value_compare</span><span class="special">;</span>
    200. 

  200.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">hasher</span><span class="special">;</span>
    201. 

  201.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">key_equal</span><span class="special">;</span>
    202. 

  202.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">allocator_type</span><span class="special">;</span>
    203. 

  203.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">reference</span><span class="special">;</span>
    204. 

  204.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_reference</span><span class="special">;</span>
    205. 

  205.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">iterator</span><span class="special">;</span>
    206. 

  206.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_iterator</span><span class="special">;</span>
    207. 

  207.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">size_type</span><span class="special">;</span>
    208. 

  208.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">difference_type</span><span class="special">;</span>
    209. 

  209.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">pointer</span><span class="special">;</span>
    210. 

  210.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_pointer</span><span class="special">;</span>
    211. 

  211.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">local_iterator</span><span class="special">;</span>
    212. 

  212.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">const_local_iterator</span><span class="special">;</span>
    213. 

  213. 

  214.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">info_type</span><span class="special">;</span>
    215. 

  215. 

  216.     <span class="comment">// construct/destroy/copy:</span>
    217. 

  217. 

  218.     <span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    219. 

  219. 

  220.     <span class="identifier">allocator_type</span> <span class="identifier">get_allocator</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    221. 

  221. 

  222.     <span class="comment">// size and capacity</span>
    223. 

  223. 

  224.     <span class="keyword">bool</span>      <span class="identifier">empty</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    225. 

  225.     <span class="identifier">size_type</span> <span class="identifier">size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    226. 

  226.     <span class="identifier">size_type</span> <span class="identifier">max_size</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    227. 

  227. 

  228.     <span class="comment">// iterators</span>
    229. 

  229. 

  230.     <span class="identifier">iterator</span>       <span class="identifier">begin</span><span class="special">();</span>
    231. 

  231.     <span class="identifier">const_iterator</span> <span class="identifier">begin</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    232. 

  232.     <span class="identifier">iterator</span>       <span class="identifier">end</span><span class="special">();</span>
    233. 

  233.     <span class="identifier">const_iterator</span> <span class="identifier">end</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    234. 

  234. 

  235.     <span class="comment">// modifiers</span>
    236. 

  236. 

  237.     <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="keyword">bool</span> <span class="special">&gt;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_insert_value">insert</a><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>
    238. 

  238. 

  239.     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_insert_iterator_value">insert</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
    240. 

  240. 

  241.     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">InputIterator</span> <span class="special">&gt;</span>
    242. 

  242.     <span class="keyword">void</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_insert_iterator_iterator">insert</a><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
    243. 

  243. 

  244.     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_erase_iterator">erase</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">);</span>
    245. 

  245. 

  246.     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    247. 

  247.     <span class="identifier">size_type</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_erase_key">erase</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    248. 

  248. 

  249.     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_erase_iterator_iterator">erase</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">last</span><span class="special">);</span>
    250. 

  250. 

  251.     <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_replace_iterator_value">replace</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
    252. 

  252. 

  253.     <span class="comment">// Only in map views</span>
    254. 

  254.     <span class="comment">// {</span>
    255. 

  255. 

  256.       <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">mapped_type</span><span class="special">;</span>
    257. 

  257.       <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">data_type</span><span class="special">;</span> <span class="comment">// Equal to mapped_type</span>
    258. 

  258. 

  259.       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    260. 

  260.       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_replace_key_iterator_key">replace_key</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    261. 

  261. 

  262.       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleData</span> <span class="special">&gt;</span>
    263. 

  263.       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_replace_data_iterator_data">replace_data</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleData</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    264. 

  264. 

  265.       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">KeyModifier</span> <span class="special">&gt;</span>
    266. 

  266.       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_modify_key_iterator_modifier">modify_key</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">KeyModifier</span> <span class="identifier">mod</span><span class="special">);</span>
    267. 

  267. 

  268.       <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">DataModifier</span> <span class="special">&gt;</span>
    269. 

  269.       <span class="keyword">bool</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_modify_data_iterator_modifier">modify_data</a><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">DataModifier</span> <span class="identifier">mod</span><span class="special">);</span>
    270. 

  270. 

  271.     <span class="comment">// }</span>
    272. 

  272. 

  273. 

  274.     <span class="keyword">void</span> <span class="identifier">clear</span><span class="special">();</span>
    275. 

  275. 

  276.     <span class="comment">// observers</span>
    277. 

  277. 

  278.     <span class="identifier">key_from_value</span> <span class="identifier">key_extractor</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    279. 

  279.     <span class="identifier">hasher</span>         <span class="identifier">hash_function</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    280. 

  280.     <span class="identifier">key_equal</span>      <span class="identifier">key_eq</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    281. 

  281. 

  282.     <span class="comment">// lookup</span>
    283. 

  283. 

  284.     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    285. 

  285.     <span class="identifier">iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_find_key">find</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    286. 

  286. 

  287.     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    288. 

  288.     <span class="identifier">const_iterator</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_find_key">find</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    289. 

  289. 

  290.     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    291. 

  291.     <span class="identifier">size_type</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_count_key">count</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    292. 

  292. 

  293.     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    294. 

  294.     <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span><span class="identifier">iterator</span><span class="special">&gt;</span>
    295. 

  295.         <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_equal_range_key">equal_range</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    296. 

  296. 

  297.     <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    298. 

  298.     <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_iterator</span><span class="special">,</span><span class="identifier">const_iterator</span><span class="special">&gt;</span>
    299. 

  299.         <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_equal_range_key">equal_range</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    300. 

  300. 

  301.     <span class="comment">// bucket interface</span>
    302. 

  302. 

  303.     <span class="identifier">size_type</span> <span class="identifier">bucket_count</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    304. 

  304.     <span class="identifier">size_type</span> <span class="identifier">max_bucket_count</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    305. 

  305.     <span class="identifier">size_type</span> <span class="identifier">bucket_size</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    306. 

  306.     <span class="identifier">size_type</span> <span class="identifier">bucket</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    307. 

  307. 

  308.     <span class="identifier">local_iterator</span>       <span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
    309. 

  309.     <span class="identifier">const_local_iterator</span> <span class="identifier">begin</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    310. 

  310.     <span class="identifier">local_iterator</span>       <span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
    311. 

  311.     <span class="identifier">const_local_iterator</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    312. 

  312. 

  313.     <span class="comment">// hash policy</span>
    314. 

  314. 

  315.     <span class="keyword">float</span> <span class="identifier">load_factor</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    316. 

  316.     <span class="keyword">float</span> <span class="identifier">max_load_factor</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
    317. 

  317.     <span class="keyword">void</span>  <span class="identifier">max_load_factor</span><span class="special">(</span><span class="keyword">float</span> <span class="identifier">z</span><span class="special">);</span>
    318. 

  318.     <span class="keyword">void</span>  <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_rehash_size">rehash</a><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
    319. 

  319. 

  320.     <span class="comment">// Only in maps views</span>
    321. 

  321.     <span class="comment">// {</span>
    322. 

  322. 

  323.     <span class="keyword">typedef</span> <span class="emphasis"><em>-unspecified-</em></span> <span class="identifier">mapped_type</span><span class="special">;</span>
    324. 

  324. 

  325.       <span class="comment">// Only in for `unordered_set_of` collection type</span>
    326. 

  326.       <span class="comment">// {</span>
    327. 

  327. 

  328.       <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompatibleKey</span><span class="special">&gt;</span>
    329. 

  329.       <span class="keyword">const</span> <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_at_key_const">at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    330. 

  330. 

  331.         <span class="comment">// Only if the other collection type is mutable</span>
    332. 

  332.         <span class="comment">// {</span>
    333. 

  333. 

  334.         <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompatibleKey</span><span class="special">&gt;</span>
    335. 

  335.         <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_operator_bracket_key">operator[]</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
    336. 

  336. 

  337.         <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">CompatibleKey</span><span class="special">&gt;</span>
    338. 

  338.         <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_at_key">at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
    339. 

  339. 

  340.         <span class="comment">// }</span>
    341. 

  341. 

  342.         <span class="comment">// Only if info_hook is used</span>
    343. 

  343.         <span class="comment">// {</span>
    344. 

  344. 

  345.         <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    346. 

  346.         <span class="identifier">info_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_info_at_key">info_at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
    347. 

  347. 

  348.         <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    349. 

  349.         <span class="keyword">const</span> <span class="identifier">info_type</span> <span class="special">&amp;</span> <a class="link" href="unordered_set_of_reference.html#reference_unordered_set_of_info_at_key">info_at</a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    350. 

  350. 

  351.       <span class="comment">// }</span>
    352. 

  352. 

  353.     <span class="comment">// }</span>
    354. 

  354. 

  355. <span class="special">};</span>
    356. 

  356. 

  357. <span class="special">}</span> <span class="comment">// namespace views</span>
    358. 

  358. <span class="special">}</span> <span class="comment">// namespace bimap</span>
    359. 

  359. <span class="special">}</span> <span class="comment">// namespace boost</span>
    360. 

  360. </pre>
    361. 

  361. <p>
    362. 

  362.           In the case of a <code class="computeroutput"><span class="identifier">bimap</span><span class="special">&lt;</span> <span class="identifier">unordered_</span><span class="special">{</span><span class="identifier">multi</span><span class="special">}</span><span class="identifier">set_of</span><span class="special">&lt;</span><span class="identifier">Left</span><span class="special">&gt;,</span> <span class="special">...</span> <span class="special">&gt;</span></code>
    363. 

  363.         </p>
    364. 

  364. <p>
    365. 

  365.           In the set view:
    366. 

  366.         </p>
    367. 

  367. <pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">relation</span><span class="special">&lt;</span>       <span class="identifier">Left</span><span class="special">,</span> <span class="special">...</span> <span class="special">&gt;</span> <span class="identifier">key_type</span><span class="special">;</span>
    368. 

  368. <span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">relation</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Left</span><span class="special">,</span> <span class="special">...</span> <span class="special">&gt;</span> <span class="identifier">value_type</span><span class="special">;</span>
    369. 

  369. </pre>
    370. 

  370. <p>
    371. 

  371.           In the left map view:
    372. 

  372.         </p>
    373. 

  373. <pre class="programlisting"><span class="keyword">typedef</span>  <span class="identifier">Left</span>  <span class="identifier">key_type</span><span class="special">;</span>
    374. 

  374. <span class="keyword">typedef</span>  <span class="special">...</span>   <span class="identifier">mapped_type</span><span class="special">;</span>
    375. 

  375. 

  376. <span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="keyword">const</span> <span class="identifier">Left</span><span class="special">,</span> <span class="special">...</span> <span class="special">&gt;</span> <span class="identifier">value_type</span><span class="special">;</span>
    377. 

  377. </pre>
    378. 

  378. <p>
    379. 

  379.           In the right map view:
    380. 

  380.         </p>
    381. 

  381. <pre class="programlisting"><span class="keyword">typedef</span>  <span class="special">...</span>  <span class="identifier">key_type</span><span class="special">;</span>
    382. 

  382. <span class="keyword">typedef</span>  <span class="identifier">Left</span> <span class="identifier">mapped_type</span><span class="special">;</span>
    383. 

  383. 

  384. <span class="keyword">typedef</span> <span class="identifier">signature</span><span class="special">-</span><span class="identifier">compatible</span> <span class="identifier">with</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="special">...</span> <span class="special">,</span><span class="keyword">const</span> <span class="identifier">Left</span> <span class="special">&gt;</span> <span class="identifier">value_type</span><span class="special">;</span>
    385. 

  385. </pre>
    386. 

  386. <div class="section">
    387. 

  387. <div class="titlepage"><div><div><h5 class="title">
    388. 

  388. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature"></a><a name="unordered_set_of_complexity_signature"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.complexity_signature" title="Complexity signature">Complexity
    389. 

  389.           signature</a>
    390. 

  390. </h5></div></div></div>
    391. 

  391. <p>
    392. 

  392.             Here and in the descriptions of operations of <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
    393. 

  393.             views, we adopt the scheme outlined in the <a class="link" href="bimap_reference.html#complexity_signature_explanation">complexity
    394. 

  394.             signature section</a>. The complexity signature of <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
    395. 

  395.             view is:
    396. 

  396.           </p>
    397. 

  397. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    398. 

  398. <li class="listitem">
    399. 

  399.                 copying: <code class="computeroutput"><span class="identifier">c</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span> <span class="special">*</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code>,
    400. 

  400.               </li>
    401. 

  401. <li class="listitem">
    402. 

  402.                 insertion: average case <code class="computeroutput"><span class="identifier">i</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">i</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>,
    403. 

  403.               </li>
    404. 

  404. <li class="listitem">
    405. 

  405.                 hinted insertion: average case <code class="computeroutput"><span class="identifier">h</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">h</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>,
    406. 

  406.               </li>
    407. 

  407. <li class="listitem">
    408. 

  408.                 deletion: average case <code class="computeroutput"><span class="identifier">d</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">d</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>,
    409. 

  409.               </li>
    410. 

  410. <li class="listitem">
    411. 

  411.                 replacement:
    412. 

  412.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    413. 

  413. <li class="listitem">
    414. 

  414.                       if the new element key is equivalent to the original, <code class="computeroutput"><span class="identifier">r</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span>
    415. 

  415.                       <span class="special">=</span> <span class="number">1</span></code>
    416. 

  416.                       (constant),
    417. 

  417.                     </li>
    418. 

  418. <li class="listitem">
    419. 

  419.                       otherwise, average case <code class="computeroutput"><span class="identifier">r</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span>
    420. 

  420.                       <span class="number">1</span></code> (constant), worst case
    421. 

  421.                       <code class="computeroutput"><span class="identifier">r</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span>
    422. 

  422.                       <span class="special">=</span> <span class="identifier">n</span></code>,
    423. 

  423.                     </li>
    424. 

  424. </ul></div>
    425. 

  425.               </li>
    426. 

  426. <li class="listitem">
    427. 

  427.                 modifying: average case <code class="computeroutput"><span class="identifier">m</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="number">1</span></code> (constant), worst case <code class="computeroutput"><span class="identifier">m</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">=</span> <span class="identifier">n</span></code>.
    428. 

  428.               </li>
    429. 

  429. </ul></div>
    430. 

  430. </div>
    431. 

  431. <div class="section">
    432. 

  432. <div class="titlepage"><div><div><h5 class="title">
    433. 

  433. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.instantiation_types" title="Instantiation types">Instantiation
    434. 

  434.           types</a>
    435. 

  435. </h5></div></div></div>
    436. 

  436. <p>
    437. 

  437.             <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> views are instantiated internally
    438. 

  438.             to <code class="computeroutput"><span class="identifier">bimap</span></code> specified by
    439. 

  439.             means of the collection type specifiers and the <code class="computeroutput"><span class="identifier">bimap</span></code>
    440. 

  440.             itself. Instantiations are dependent on the following types:
    441. 

  441.           </p>
    442. 

  442. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    443. 

  443. <li class="listitem">
    444. 

  444.                 <code class="computeroutput"><span class="identifier">Value</span></code> from <code class="computeroutput"><span class="identifier">bimap</span></code>,
    445. 

  445.               </li>
    446. 

  446. <li class="listitem">
    447. 

  447.                 <code class="computeroutput"><span class="identifier">Allocator</span></code> from <code class="computeroutput"><span class="identifier">bimap</span></code>,
    448. 

  448.               </li>
    449. 

  449. <li class="listitem">
    450. 

  450.                 <code class="computeroutput"><span class="identifier">Hash</span></code> from the collection
    451. 

  451.                 type specifier,
    452. 

  452.               </li>
    453. 

  453. <li class="listitem">
    454. 

  454.                 <code class="computeroutput"><span class="identifier">Pred</span></code> from the collection
    455. 

  455.                 type specifier.
    456. 

  456.               </li>
    457. 

  457. </ul></div>
    458. 

  458. <p>
    459. 

  459.             <code class="computeroutput"><span class="identifier">Hash</span></code> is a <a href="https://www.boost.org/sgi/stl/UnaryFunction.html" target="_top">Unary
    460. 

  460.             Function</a> taking a single argument of type <code class="computeroutput"><span class="identifier">key_type</span></code>
    461. 

  461.             and returning a value of type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span></code>
    462. 

  462.             in the range <code class="computeroutput"><span class="special">[</span><span class="number">0</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span><span class="special">&gt;::</span><span class="identifier">max</span><span class="special">())</span></code>. Pred is a <a href="https://www.boost.org/sgi/stl/BinaryPredicate.html" target="_top">Binary
    463. 

  463.             Predicate</a> inducing an equivalence relation on elements of <code class="computeroutput"><span class="identifier">key_type</span></code>. It is required that the
    464. 

  464.             <code class="computeroutput"><span class="identifier">Hash</span></code> object return the
    465. 

  465.             same value for keys equivalent under <code class="computeroutput"><span class="identifier">Pred</span></code>.
    466. 

  466.           </p>
    467. 

  467. </div>
    468. 

  468. <div class="section">
    469. 

  469. <div class="titlepage"><div><div><h5 class="title">
    470. 

  470. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.nested_types" title="Nested types">Nested
    471. 

  471.           types</a>
    472. 

  472. </h5></div></div></div>
    473. 

  473. <pre class="programlisting"><span class="identifier">iterator</span>
    474. 

  474. <span class="identifier">const_iterator</span>
    475. 

  475. <span class="identifier">local_iterator</span>
    476. 

  476. <span class="identifier">const_local_iterator</span>
    477. 

  477. </pre>
    478. 

  478. <div class="blockquote"><blockquote class="blockquote"><p>
    479. 

  479.               These types are models of <a href="https://www.boost.org/sgi/stl/ForwardIterator.html" target="_top">Forward
    480. 

  480.               Iterator</a>.
    481. 

  481.             </p></blockquote></div>
    482. 

  482. </div>
    483. 

  483. <div class="section">
    484. 

  484. <div class="titlepage"><div><div><h5 class="title">
    485. 

  485. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.constructors__copy_and_assignment" title="Constructors, copy and assignment">Constructors,
    486. 

  486.           copy and assignment</a>
    487. 

  487. </h5></div></div></div>
    488. 

  488. <p>
    489. 

  489.             As explained in the concepts section, views do not have public constructors
    490. 

  490.             or destructors. Assignment, on the other hand, is provided. Upon construction,
    491. 

  491.             <code class="computeroutput"><span class="identifier">max_load_factor</span><span class="special">()</span></code>
    492. 

  492.             is 1.0.
    493. 

  493.           </p>
    494. 

  494. <pre class="programlisting"><span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">=(</span><span class="keyword">const</span> <span class="identifier">this_type</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    495. 

  495. </pre>
    496. 

  496. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    497. 

  497. <li class="listitem">
    498. 

  498.                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">a</span>
    499. 

  499.                 <span class="special">=</span> <span class="identifier">b</span></code>;
    500. 

  500.                 where a and b are the <code class="computeroutput"><span class="identifier">bimap</span></code>
    501. 

  501.                 objects to which <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span></code>
    502. 

  502.                 and x belong, respectively.
    503. 

  503.               </li>
    504. 

  504. <li class="listitem">
    505. 

  505.                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="special">*</span><span class="keyword">this</span><span class="special">.</span></code>
    506. 

  506.               </li>
    507. 

  507. </ul></div>
    508. 

  508. </div>
    509. 

  509. <div class="section">
    510. 

  510. <div class="titlepage"><div><div><h5 class="title">
    511. 

  511. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.modifiers" title="Modifiers">Modifiers</a>
    512. 

  512. </h5></div></div></div>
    513. 

  513. <a name="reference_unordered_set_of_insert_value"></a><pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span><span class="keyword">bool</span><span class="special">&gt;</span> <span class="identifier">insert</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>
    514. 

  514. </pre>
    515. 

  515. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    516. 

  516. <li class="listitem">
    517. 

  517.                 <span class="bold"><strong>Effects:</strong></span> Inserts <code class="computeroutput"><span class="identifier">x</span></code>
    518. 

  518.                 into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
    519. 

  519.                 which the view belongs if
    520. 

  520.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    521. 

  521. <li class="listitem">
    522. 

  522.                       the view is non-unique OR no other element with equivalent
    523. 

  523.                       key exists,
    524. 

  524.                     </li>
    525. 

  525. <li class="listitem">
    526. 

  526.                       AND insertion is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
    527. 

  527.                     </li>
    528. 

  528. </ul></div>
    529. 

  529.               </li>
    530. 

  530. <li class="listitem">
    531. 

  531.                 <span class="bold"><strong>Returns:</strong></span> The return value is a pair
    532. 

  532.                 <code class="computeroutput"><span class="identifier">p</span></code>. <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">second</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
    533. 

  533.                 if and only if insertion took place. On successful insertion, <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span></code> points to the element inserted;
    534. 

  534.                 otherwise, <code class="computeroutput"><span class="identifier">p</span><span class="special">.</span><span class="identifier">first</span></code> points to an element that
    535. 

  535.                 caused the insertion to be banned. Note that more than one element
    536. 

  536.                 can be causing insertion not to be allowed.
    537. 

  537.               </li>
    538. 

  538. <li class="listitem">
    539. 

  539.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    540. 

  540.                 O(I(n)).
    541. 

  541.               </li>
    542. 

  542. <li class="listitem">
    543. 

  543.                 <span class="bold"><strong>Exception safety:</strong></span> Strong.
    544. 

  544.               </li>
    545. 

  545. </ul></div>
    546. 

  546. <a name="reference_unordered_set_of_insert_iterator_value"></a><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
    547. 

  547. </pre>
    548. 

  548. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    549. 

  549. <li class="listitem">
    550. 

  550.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
    551. 

  551.                 is a valid iterator of the view.
    552. 

  552.               </li>
    553. 

  553. <li class="listitem">
    554. 

  554.                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
    555. 

  555.                 is used as a hint to improve the efficiency of the operation. Inserts
    556. 

  556.                 <code class="computeroutput"><span class="identifier">x</span></code> into the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the view belongs
    557. 

  557.                 if
    558. 

  558.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    559. 

  559. <li class="listitem">
    560. 

  560.                       the view is non-unique OR no other element with equivalent
    561. 

  561.                       key exists,
    562. 

  562.                     </li>
    563. 

  563. <li class="listitem">
    564. 

  564.                       AND insertion is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
    565. 

  565.                     </li>
    566. 

  566. </ul></div>
    567. 

  567.               </li>
    568. 

  568. <li class="listitem">
    569. 

  569.                 <span class="bold"><strong>Returns:</strong></span> On successful insertion,
    570. 

  570.                 an iterator to the newly inserted element. Otherwise, an iterator
    571. 

  571.                 to an element that caused the insertion to be banned. Note that more
    572. 

  572.                 than one element can be causing insertion not to be allowed.
    573. 

  573.               </li>
    574. 

  574. <li class="listitem">
    575. 

  575.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    576. 

  576.                 O(H(n)).
    577. 

  577.               </li>
    578. 

  578. <li class="listitem">
    579. 

  579.                 <span class="bold"><strong>Exception safety:</strong></span> Strong.
    580. 

  580.               </li>
    581. 

  581. </ul></div>
    582. 

  582. <a name="reference_unordered_set_of_insert_iterator_iterator"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
    583. 

  583. <span class="keyword">void</span> <span class="identifier">insert</span><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">InputIterator</span> <span class="identifier">last</span><span class="special">);</span>
    584. 

  584. </pre>
    585. 

  585. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    586. 

  586. <li class="listitem">
    587. 

  587.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">InputIterator</span></code>
    588. 

  588.                 is a model of <a href="https://www.boost.org/sgi/stl/InputIterator.html" target="_top">Input
    589. 

  589.                 Iterator</a> over elements of type <code class="computeroutput"><span class="identifier">value_type</span></code>.
    590. 

  590.                 <code class="computeroutput"><span class="identifier">first</span></code> and <code class="computeroutput"><span class="identifier">last</span></code> are not iterators into any
    591. 

  591.                 views of the <code class="computeroutput"><span class="identifier">bimap</span></code>
    592. 

  592.                 to which this view belongs. <code class="computeroutput"><span class="identifier">last</span></code>
    593. 

  593.                 is reachable from first.
    594. 

  594.               </li>
    595. 

  595. <li class="listitem">
    596. 

  596.                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="identifier">iterator</span>
    597. 

  597.                 <span class="identifier">hint</span> <span class="special">=</span>
    598. 

  598.                 <span class="identifier">end</span><span class="special">();</span></code>
    599. 

  599.                 <code class="computeroutput"><span class="keyword">while</span><span class="special">(</span><span class="identifier">first</span> <span class="special">!=</span>
    600. 

  600.                 <span class="identifier">last</span><span class="special">)</span>
    601. 

  601.                 <span class="identifier">hint</span> <span class="special">=</span>
    602. 

  602.                 <span class="identifier">insert</span><span class="special">(</span><span class="identifier">hint</span><span class="special">,</span>
    603. 

  603.                 <span class="special">*</span><span class="identifier">first</span><span class="special">++);</span></code>
    604. 

  604.               </li>
    605. 

  605. <li class="listitem">
    606. 

  606.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    607. 

  607.                 O(m*H(n+m)), where m is the number of elements in <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span>
    608. 

  608.                 <span class="identifier">last</span><span class="special">)</span></code>.
    609. 

  609.               </li>
    610. 

  610. <li class="listitem">
    611. 

  611.                 <span class="bold"><strong>Exception safety:</strong></span> Basic.
    612. 

  612.               </li>
    613. 

  613. </ul></div>
    614. 

  614. <a name="reference_unordered_set_of_erase_iterator"></a><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">);</span>
    615. 

  615. </pre>
    616. 

  616. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    617. 

  617. <li class="listitem">
    618. 

  618.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
    619. 

  619.                 is a valid dereferenceable <code class="computeroutput"><span class="identifier">iterator</span></code>
    620. 

  620.                 of the view.
    621. 

  621.               </li>
    622. 

  622. <li class="listitem">
    623. 

  623.                 <span class="bold"><strong>Effects:</strong></span> Deletes the element pointed
    624. 

  624.                 to by <code class="computeroutput"><span class="identifier">position</span></code>.
    625. 

  625.               </li>
    626. 

  626. <li class="listitem">
    627. 

  627.                 <span class="bold"><strong>Returns:</strong></span> An <code class="computeroutput"><span class="identifier">iterator</span></code>
    628. 

  628.                 pointing to the element immediately following the one that was deleted,
    629. 

  629.                 or <code class="computeroutput"><span class="identifier">end</span><span class="special">()</span></code>
    630. 

  630.                 if no such element exists.
    631. 

  631.               </li>
    632. 

  632. <li class="listitem">
    633. 

  633.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    634. 

  634.                 O(D(n)).
    635. 

  635.               </li>
    636. 

  636. <li class="listitem">
    637. 

  637.                 <span class="bold"><strong>Exception safety:</strong></span> nothrow.
    638. 

  638.               </li>
    639. 

  639. </ul></div>
    640. 

  640. <a name="reference_unordered_set_of_erase_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    641. 

  641. <span class="identifier">size_type</span> <span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    642. 

  642. </pre>
    643. 

  643. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    644. 

  644. <li class="listitem">
    645. 

  645.                 <span class="bold"><strong>Effects:</strong></span> Deletes the elements with
    646. 

  646.                 key equivalent to <code class="computeroutput"><span class="identifier">x</span></code>.
    647. 

  647.               </li>
    648. 

  648. <li class="listitem">
    649. 

  649.                 <span class="bold"><strong>Returns:</strong></span> Number of elements deleted.
    650. 

  650.               </li>
    651. 

  651. <li class="listitem">
    652. 

  652.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    653. 

  653.                 Average case, O(1 + m*D(n)), worst case O(n + m*D(n)), where m is
    654. 

  654.                 the number of elements deleted.
    655. 

  655.               </li>
    656. 

  656. <li class="listitem">
    657. 

  657.                 <span class="bold"><strong>Exception safety:</strong></span> Basic.
    658. 

  658.               </li>
    659. 

  659. </ul></div>
    660. 

  660. <a name="reference_unordered_set_of_erase_iterator_iterator"></a><pre class="programlisting"><span class="identifier">iterator</span> <span class="identifier">erase</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="identifier">last</span><span class="special">);</span>
    661. 

  661. </pre>
    662. 

  662. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    663. 

  663. <li class="listitem">
    664. 

  664.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>
    665. 

  665.                 is a valid range of the view.
    666. 

  666.               </li>
    667. 

  667. <li class="listitem">
    668. 

  668.                 <span class="bold"><strong>Effects:</strong></span> Deletes the elements in
    669. 

  669.                 <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>.
    670. 

  670.               </li>
    671. 

  671. <li class="listitem">
    672. 

  672.                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="identifier">last</span></code>.
    673. 

  673.               </li>
    674. 

  674. <li class="listitem">
    675. 

  675.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    676. 

  676.                 O(m*D(n)), where m is the number of elements in <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">last</span><span class="special">)</span></code>.
    677. 

  677.               </li>
    678. 

  678. <li class="listitem">
    679. 

  679.                 <span class="bold"><strong>Exception safety:</strong></span> nothrow.
    680. 

  680.               </li>
    681. 

  681. </ul></div>
    682. 

  682. <a name="reference_unordered_set_of_replace_iterator_value"></a><pre class="programlisting"><span class="keyword">bool</span> <span class="identifier">replace</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</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>
    683. 

  683. </pre>
    684. 

  684. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    685. 

  685. <li class="listitem">
    686. 

  686.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
    687. 

  687.                 is a valid dereferenceable <code class="computeroutput"><span class="identifier">iterator</span></code>
    688. 

  688.                 of the view.
    689. 

  689.               </li>
    690. 

  690. <li class="listitem">
    691. 

  691.                 <span class="bold"><strong>Effects:</strong></span> Assigns the value <code class="computeroutput"><span class="identifier">x</span></code> to the element pointed to by
    692. 

  692.                 <code class="computeroutput"><span class="identifier">position</span></code> into the
    693. 

  693.                 <code class="computeroutput"><span class="identifier">bimap</span></code> to which the
    694. 

  694.                 view belongs if, for the value <code class="computeroutput"><span class="identifier">x</span></code>
    695. 

  695.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    696. 

  696. <li class="listitem">
    697. 

  697.                       the view is non-unique OR no other element with equivalent
    698. 

  698.                       key exists (except possibly <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code>),
    699. 

  699.                     </li>
    700. 

  700. <li class="listitem">
    701. 

  701.                       AND replacing is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
    702. 

  702.                     </li>
    703. 

  703. </ul></div>
    704. 

  704.               </li>
    705. 

  705. <li class="listitem">
    706. 

  706.                 <span class="bold"><strong>Postconditions:</strong></span> Validity of position
    707. 

  707.                 is preserved in all cases.
    708. 

  708.               </li>
    709. 

  709. <li class="listitem">
    710. 

  710.                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
    711. 

  711.                 if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
    712. 

  712.                 otherwise.
    713. 

  713.               </li>
    714. 

  714. <li class="listitem">
    715. 

  715.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    716. 

  716.                 O(R(n)).
    717. 

  717.               </li>
    718. 

  718. <li class="listitem">
    719. 

  719.                 <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
    720. 

  720.                 exception is thrown by some user-provided operation the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the view belongs
    721. 

  721.                 remains in its original state.
    722. 

  722.               </li>
    723. 

  723. </ul></div>
    724. 

  724. <a name="reference_unordered_set_of_replace_key_iterator_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    725. 

  725. <span class="keyword">bool</span> <span class="identifier">replace_key</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    726. 

  726. </pre>
    727. 

  727. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    728. 

  728. <li class="listitem">
    729. 

  729.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
    730. 

  730.                 is a valid dereferenceable iterator of the set view. <code class="computeroutput"><span class="identifier">CompatibleKey</span></code> can be assigned to
    731. 

  731.                 <code class="computeroutput"><span class="identifier">key_type</span></code>.
    732. 

  732.               </li>
    733. 

  733. <li class="listitem">
    734. 

  734.                 <span class="bold"><strong>Effects:</strong></span> Assigns the value <code class="computeroutput"><span class="identifier">x</span></code> to <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">first</span></code>,
    735. 

  735.                 where <code class="computeroutput"><span class="identifier">e</span></code> is the element
    736. 

  736.                 pointed to by <code class="computeroutput"><span class="identifier">position</span></code>
    737. 

  737.                 into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
    738. 

  738.                 which the set view belongs if,
    739. 

  739.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    740. 

  740. <li class="listitem">
    741. 

  741.                       the map view is non-unique OR no other element with equivalent
    742. 

  742.                       key exists (except possibly <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code>),
    743. 

  743.                     </li>
    744. 

  744. <li class="listitem">
    745. 

  745.                       AND replacing is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
    746. 

  746.                     </li>
    747. 

  747. </ul></div>
    748. 

  748.               </li>
    749. 

  749. <li class="listitem">
    750. 

  750.                 <span class="bold"><strong>Postconditions:</strong></span> Validity of position
    751. 

  751.                 is preserved in all cases.
    752. 

  752.               </li>
    753. 

  753. <li class="listitem">
    754. 

  754.                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
    755. 

  755.                 if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
    756. 

  756.                 otherwise.
    757. 

  757.               </li>
    758. 

  758. <li class="listitem">
    759. 

  759.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    760. 

  760.                 O(R(n)).
    761. 

  761.               </li>
    762. 

  762. <li class="listitem">
    763. 

  763.                 <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
    764. 

  764.                 exception is thrown by some user-provided operation, the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the set view belongs
    765. 

  765.                 remains in its original state.
    766. 

  766.               </li>
    767. 

  767. </ul></div>
    768. 

  768. <a name="reference_unordered_set_of_replace_data_iterator_data"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleData</span> <span class="special">&gt;</span>
    769. 

  769. <span class="keyword">bool</span> <span class="identifier">replace_data</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">CompatibleData</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    770. 

  770. </pre>
    771. 

  771. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    772. 

  772. <li class="listitem">
    773. 

  773.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">position</span></code>
    774. 

  774.                 is a valid dereferenceable iterator of the set view. <code class="computeroutput"><span class="identifier">CompatibleKey</span></code> can be assigned to
    775. 

  775.                 <code class="computeroutput"><span class="identifier">mapped_type</span></code>.
    776. 

  776.               </li>
    777. 

  777. <li class="listitem">
    778. 

  778.                 <span class="bold"><strong>Effects:</strong></span> Assigns the value <code class="computeroutput"><span class="identifier">x</span></code> to <code class="computeroutput"><span class="identifier">e</span><span class="special">.</span><span class="identifier">second</span></code>,
    779. 

  779.                 where <code class="computeroutput"><span class="identifier">e</span></code> is the element
    780. 

  780.                 pointed to by <code class="computeroutput"><span class="identifier">position</span></code>
    781. 

  781.                 into the <code class="computeroutput"><span class="identifier">bimap</span></code> to
    782. 

  782.                 which the set view belongs if,
    783. 

  783.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    784. 

  784. <li class="listitem">
    785. 

  785.                       the map view is non-unique OR no other element with equivalent
    786. 

  786.                       key exists (except possibly <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code>),
    787. 

  787.                     </li>
    788. 

  788. <li class="listitem">
    789. 

  789.                       AND replacing is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
    790. 

  790.                     </li>
    791. 

  791. </ul></div>
    792. 

  792.               </li>
    793. 

  793. <li class="listitem">
    794. 

  794.                 <span class="bold"><strong>Postconditions:</strong></span> Validity of position
    795. 

  795.                 is preserved in all cases.
    796. 

  796.               </li>
    797. 

  797. <li class="listitem">
    798. 

  798.                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
    799. 

  799.                 if the replacement took place, <code class="computeroutput"><span class="keyword">false</span></code>
    800. 

  800.                 otherwise.
    801. 

  801.               </li>
    802. 

  802. <li class="listitem">
    803. 

  803.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    804. 

  804.                 O(R(n)).
    805. 

  805.               </li>
    806. 

  806. <li class="listitem">
    807. 

  807.                 <span class="bold"><strong>Exception safety:</strong></span> Strong. If an
    808. 

  808.                 exception is thrown by some user-provided operation, the <code class="computeroutput"><span class="identifier">bimap</span></code> to which the set view belongs
    809. 

  809.                 remains in its original state.
    810. 

  810.               </li>
    811. 

  811. </ul></div>
    812. 

  812. <a name="reference_unordered_set_of_modify_key_iterator_modifier"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">KeyModifier</span> <span class="special">&gt;</span>
    813. 

  813. <span class="keyword">bool</span> <span class="identifier">modify_key</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">KeyModifier</span> <span class="identifier">mod</span><span class="special">);</span>
    814. 

  814. </pre>
    815. 

  815. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    816. 

  816. <li class="listitem">
    817. 

  817.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">KeyModifier</span></code>
    818. 

  818.                 is a model of <a href="https://www.boost.org/sgi/stl/UnaryFunction.html" target="_top">Unary
    819. 

  819.                 Function</a> accepting arguments of type: <code class="computeroutput"><span class="identifier">key_type</span><span class="special">&amp;</span></code>; <code class="computeroutput"><span class="identifier">position</span></code>
    820. 

  820.                 is a valid dereferenceable iterator of the view.
    821. 

  821.               </li>
    822. 

  822. <li class="listitem">
    823. 

  823.                 <span class="bold"><strong>Effects:</strong></span> Calls <code class="computeroutput"><span class="identifier">mod</span><span class="special">(</span><span class="identifier">e</span><span class="special">.</span><span class="identifier">first</span><span class="special">)</span></code> where e is the element pointed to
    824. 

  824.                 by position and rearranges <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code> into all the views of
    825. 

  825.                 the <code class="computeroutput"><span class="identifier">bimap</span></code>. If the
    826. 

  826.                 rearrangement fails, the element is erased. Rearrangement is successful
    827. 

  827.                 if
    828. 

  828.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    829. 

  829. <li class="listitem">
    830. 

  830.                       the map view is non-unique OR no other element with equivalent
    831. 

  831.                       key exists,
    832. 

  832.                     </li>
    833. 

  833. <li class="listitem">
    834. 

  834.                       AND rearrangement is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
    835. 

  835.                     </li>
    836. 

  836. </ul></div>
    837. 

  837.               </li>
    838. 

  838. <li class="listitem">
    839. 

  839.                 <span class="bold"><strong>Postconditions:</strong></span> Validity of <code class="computeroutput"><span class="identifier">position</span></code> is preserved if the operation
    840. 

  840.                 succeeds.
    841. 

  841.               </li>
    842. 

  842. <li class="listitem">
    843. 

  843.                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
    844. 

  844.                 if the operation succeeded, <code class="computeroutput"><span class="keyword">false</span></code>
    845. 

  845.                 otherwise.
    846. 

  846.               </li>
    847. 

  847. <li class="listitem">
    848. 

  848.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    849. 

  849.                 O(M(n)).
    850. 

  850.               </li>
    851. 

  851. <li class="listitem">
    852. 

  852.                 <span class="bold"><strong>Exception safety:</strong></span> Basic. If an exception
    853. 

  853.                 is thrown by some user-provided operation (except possibly mod),
    854. 

  854.                 then the element pointed to by position is erased.
    855. 

  855.               </li>
    856. 

  856. <li class="listitem">
    857. 

  857.                 <span class="bold"><strong>Note:</strong></span> Only provided for map views.
    858. 

  858.               </li>
    859. 

  859. </ul></div>
    860. 

  860. <a name="reference_unordered_set_of_modify_data_iterator_modifier"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">DataModifier</span> <span class="special">&gt;</span>
    861. 

  861. <span class="keyword">bool</span> <span class="identifier">modify_data</span><span class="special">(</span><span class="identifier">iterator</span> <span class="identifier">position</span><span class="special">,</span> <span class="identifier">DataModifier</span> <span class="identifier">mod</span><span class="special">);</span>
    862. 

  862. </pre>
    863. 

  863. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    864. 

  864. <li class="listitem">
    865. 

  865.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">DataModifier</span></code>
    866. 

  866.                 is a model of <a href="https://www.boost.org/sgi/stl/UnaryFunction.html" target="_top">Unary
    867. 

  867.                 Function</a> accepting arguments of type: <code class="computeroutput"><span class="identifier">mapped_type</span><span class="special">&amp;</span></code>; <code class="computeroutput"><span class="identifier">position</span></code>
    868. 

  868.                 is a valid dereferenceable iterator of the view.
    869. 

  869.               </li>
    870. 

  870. <li class="listitem">
    871. 

  871.                 <span class="bold"><strong>Effects:</strong></span> Calls <code class="computeroutput"><span class="identifier">mod</span><span class="special">(</span><span class="identifier">e</span><span class="special">.</span><span class="identifier">second</span><span class="special">)</span></code> where e is the element pointed to
    872. 

  872.                 by position and rearranges <code class="computeroutput"><span class="special">*</span><span class="identifier">position</span></code> into all the views of
    873. 

  873.                 the <code class="computeroutput"><span class="identifier">bimap</span></code>. If the
    874. 

  874.                 rearrangement fails, the element is erased. Rearrangement is successful
    875. 

  875.                 if
    876. 

  876.                 <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
    877. 

  877. <li class="listitem">
    878. 

  878.                       the oppositte map view is non-unique OR no other element with
    879. 

  879.                       equivalent key in that view exists,
    880. 

  880.                     </li>
    881. 

  881. <li class="listitem">
    882. 

  882.                       AND rearrangement is allowed by all other views of the <code class="computeroutput"><span class="identifier">bimap</span></code>.
    883. 

  883.                     </li>
    884. 

  884. </ul></div>
    885. 

  885.               </li>
    886. 

  886. <li class="listitem">
    887. 

  887.                 <span class="bold"><strong>Postconditions:</strong></span> Validity of <code class="computeroutput"><span class="identifier">position</span></code> is preserved if the operation
    888. 

  888.                 succeeds.
    889. 

  889.               </li>
    890. 

  890. <li class="listitem">
    891. 

  891.                 <span class="bold"><strong>Returns: </strong></span> <code class="computeroutput"><span class="keyword">true</span></code>
    892. 

  892.                 if the operation succeeded, <code class="computeroutput"><span class="keyword">false</span></code>
    893. 

  893.                 otherwise.
    894. 

  894.               </li>
    895. 

  895. <li class="listitem">
    896. 

  896.                 <a class="link" href="unordered_set_of_reference.html#unordered_set_of_complexity_signature"><span class="bold"><strong>Complexity:</strong></span></a>
    897. 

  897.                 O(M(n)).
    898. 

  898.               </li>
    899. 

  899. <li class="listitem">
    900. 

  900.                 <span class="bold"><strong>Exception safety:</strong></span> Basic. If an exception
    901. 

  901.                 is thrown by some user-provided operation (except possibly mod),
    902. 

  902.                 then the element pointed to by position is erased.
    903. 

  903.               </li>
    904. 

  904. <li class="listitem">
    905. 

  905.                 <span class="bold"><strong>Note:</strong></span> Only provided for map views.
    906. 

  906.               </li>
    907. 

  907. </ul></div>
    908. 

  908. </div>
    909. 

  909. <div class="section">
    910. 

  910. <div class="titlepage"><div><div><h5 class="title">
    911. 

  911. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.lookup" title="Lookup">Lookup</a>
    912. 

  912. </h5></div></div></div>
    913. 

  913. <p>
    914. 

  914.             <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> views provide the full lookup
    915. 

  915.             functionality required by unordered associative containers, namely <code class="computeroutput"><span class="identifier">find</span></code>, <code class="computeroutput"><span class="identifier">count</span></code>,
    916. 

  916.             and <code class="computeroutput"><span class="identifier">equal_range</span></code>. Additionally,
    917. 

  917.             these member functions are templatized to allow for non-standard arguments,
    918. 

  918.             so extending the types of search operations allowed. The kind of arguments
    919. 

  919.             permissible when invoking the lookup member functions is defined by the
    920. 

  920.             following concept.
    921. 

  921.           </p>
    922. 

  922. <p>
    923. 

  923.             A type <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
    924. 

  924.             is said to be a <span class="emphasis"><em>compatible key</em></span> of <code class="computeroutput"><span class="special">(</span><span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span></code> if <code class="computeroutput"><span class="special">(</span><span class="identifier">CompatibleKey</span><span class="special">,</span>
    925. 

  925.             <span class="identifier">Hash</span><span class="special">,</span>
    926. 

  926.             <span class="identifier">Pred</span><span class="special">)</span></code>
    927. 

  927.             is a compatible extension of <code class="computeroutput"><span class="special">(</span><span class="identifier">Hash</span><span class="special">,</span> <span class="identifier">Pred</span><span class="special">)</span></code>.
    928. 

  928.             This implies that <code class="computeroutput"><span class="identifier">Hash</span></code>
    929. 

  929.             and <code class="computeroutput"><span class="identifier">Pred</span></code> accept arguments
    930. 

  930.             of type <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>,
    931. 

  931.             which usually means they have several overloads of their corresponding
    932. 

  932.             <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
    933. 

  933.             member functions.
    934. 

  934.           </p>
    935. 

  935. <a name="reference_unordered_set_of_find_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    936. 

  936. <span class="identifier">iterator</span> <span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    937. 

  937. 

  938. <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    939. 

  939. <span class="identifier">const_iterator</span> <span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    940. 

  940. </pre>
    941. 

  941. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    942. 

  942. <li class="listitem">
    943. 

  943.                 <span class="bold"><strong>Effects:</strong></span> Returns a pointer to an
    944. 

  944.                 element whose key is equivalent to <code class="computeroutput"><span class="identifier">x</span></code>,
    945. 

  945.                 or <code class="computeroutput"><span class="identifier">end</span><span class="special">()</span></code>
    946. 

  946.                 if such an element does not exist.
    947. 

  947.               </li>
    948. 

  948. <li class="listitem">
    949. 

  949.                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
    950. 

  950.                 worst case O(n).
    951. 

  951.               </li>
    952. 

  952. </ul></div>
    953. 

  953. <a name="reference_unordered_set_of_count_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    954. 

  954. <span class="identifier">size_type</span> <span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    955. 

  955. </pre>
    956. 

  956. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    957. 

  957. <li class="listitem">
    958. 

  958.                 <span class="bold"><strong>Effects:</strong></span> Returns the number of elements
    959. 

  959.                 with key equivalent to <code class="computeroutput"><span class="identifier">x</span></code>.
    960. 

  960.               </li>
    961. 

  961. <li class="listitem">
    962. 

  962.                 <span class="bold"><strong>Complexity:</strong></span> Average case O(count(x)),
    963. 

  963.                 worst case O(n).
    964. 

  964.               </li>
    965. 

  965. </ul></div>
    966. 

  966. <a name="reference_unordered_set_of_equal_range_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    967. 

  967. <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span><span class="identifier">iterator</span><span class="special">&gt;</span>
    968. 

  968.     <span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">);</span>
    969. 

  969. 

  970. <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    971. 

  971. <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_iterator</span><span class="special">,</span><span class="identifier">const_iterator</span><span class="special">&gt;</span>
    972. 

  972.     <span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    973. 

  973. </pre>
    974. 

  974. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    975. 

  975. <li class="listitem">
    976. 

  976.                 <span class="bold"><strong>Effects:</strong></span> Returns a range containing
    977. 

  977.                 all elements with keys equivalent to <code class="computeroutput"><span class="identifier">x</span></code>
    978. 

  978.                 (and only those).
    979. 

  979.               </li>
    980. 

  980. <li class="listitem">
    981. 

  981.                 <span class="bold"><strong>Complexity:</strong></span> Average case O(count(x)),
    982. 

  982.                 worst case O(n).
    983. 

  983.               </li>
    984. 

  984. </ul></div>
    985. 

  985. </div>
    986. 

  986. <div class="section">
    987. 

  987. <div class="titlepage"><div><div><h5 class="title">
    988. 

  988. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.at____info_at___and_operator_______set_of_only" title="at(), info_at() and operator[] - set_of only">at(),
    989. 

  989.           info_at() and operator[] - set_of only</a>
    990. 

  990. </h5></div></div></div>
    991. 

  991. <a name="reference_unordered_set_of_at_key_const"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    992. 

  992. <span class="keyword">const</span> <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <span class="identifier">at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    993. 

  993. </pre>
    994. 

  994. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    995. 

  995. <li class="listitem">
    996. 

  996.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
    997. 

  997.                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
    998. 

  998.               </li>
    999. 

  999. <li class="listitem">
    1000. 

  1000.                 <span class="bold"><strong>Effects:</strong></span> Returns the <code class="computeroutput"><span class="identifier">mapped_type</span></code> reference that is associated
    1001. 

  1001.                 with <code class="computeroutput"><span class="identifier">k</span></code>, or throws
    1002. 

  1002.                 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">out_of_range</span></code> if such key does not
    1003. 

  1003.                 exist.
    1004. 

  1004.               </li>
    1005. 

  1005. <li class="listitem">
    1006. 

  1006.                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
    1007. 

  1007.                 worst case O(n).
    1008. 

  1008.               </li>
    1009. 

  1009. <li class="listitem">
    1010. 

  1010.                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> is used.
    1011. 

  1011.               </li>
    1012. 

  1012. </ul></div>
    1013. 

  1013. <p>
    1014. 

  1014.             The symmetry of bimap imposes some constraints on <code class="computeroutput"><span class="keyword">operator</span><span class="special">[]</span></code> and the non constant version of at()
    1015. 

  1015.             that are not found in <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">maps</span></code>.
    1016. 

  1016.             Tey are only provided if the other collection type is mutable (<code class="computeroutput"><span class="identifier">list_of</span></code>, <code class="computeroutput"><span class="identifier">vector_of</span></code>
    1017. 

  1017.             and <code class="computeroutput"><span class="identifier">unconstrained_set_of</span></code>).
    1018. 

  1018.           </p>
    1019. 

  1019. <a name="reference_unordered_set_of_operator_bracket_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    1020. 

  1020. <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <span class="keyword">operator</span><span class="special">[](</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
    1021. 

  1021. </pre>
    1022. 

  1022. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    1023. 

  1023. <li class="listitem">
    1024. 

  1024.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
    1025. 

  1025.                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
    1026. 

  1026.               </li>
    1027. 

  1027. <li class="listitem">
    1028. 

  1028.                 <span class="bold"><strong>Effects: </strong></span> <code class="computeroutput"><span class="keyword">return</span>
    1029. 

  1029.                 <span class="identifier">insert</span><span class="special">(</span><span class="identifier">value_type</span><span class="special">(</span><span class="identifier">k</span><span class="special">,</span><span class="identifier">mapped_type</span><span class="special">()))-&gt;</span><span class="identifier">second</span><span class="special">;</span></code>
    1030. 

  1030.               </li>
    1031. 

  1031. <li class="listitem">
    1032. 

  1032.                 <span class="bold"><strong>Complexity:</strong></span> If the insertion is
    1033. 

  1033.                 performed O(I(n)), else: Average case O(1) (constant), worst case
    1034. 

  1034.                 O(n).
    1035. 

  1035.               </li>
    1036. 

  1036. <li class="listitem">
    1037. 

  1037.                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> is used and the
    1038. 

  1038.                 other collection type is mutable.
    1039. 

  1039.               </li>
    1040. 

  1040. </ul></div>
    1041. 

  1041. <a name="reference_unordered_set_of_at_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    1042. 

  1042. <span class="identifier">mapped_type</span> <span class="special">&amp;</span> <span class="identifier">at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
    1043. 

  1043. </pre>
    1044. 

  1044. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    1045. 

  1045. <li class="listitem">
    1046. 

  1046.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
    1047. 

  1047.                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
    1048. 

  1048.               </li>
    1049. 

  1049. <li class="listitem">
    1050. 

  1050.                 <span class="bold"><strong>Effects: </strong></span> Returns the <code class="computeroutput"><span class="identifier">mapped_type</span></code> reference that is associated
    1051. 

  1051.                 with <code class="computeroutput"><span class="identifier">k</span></code>, or throws
    1052. 

  1052.                 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">out_of_range</span></code> if such key does not
    1053. 

  1053.                 exist.
    1054. 

  1054.               </li>
    1055. 

  1055. <li class="listitem">
    1056. 

  1056.                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
    1057. 

  1057.                 worst case O(n).
    1058. 

  1058.               </li>
    1059. 

  1059. <li class="listitem">
    1060. 

  1060.                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> is used and the
    1061. 

  1061.                 other collection type is mutable.
    1062. 

  1062.               </li>
    1063. 

  1063. </ul></div>
    1064. 

  1064. <a name="reference_unordered_set_of_info_at_key"></a><pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    1065. 

  1065. <span class="identifier">info_type</span> <span class="special">&amp;</span> <span class="identifier">info_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">);</span>
    1066. 

  1066. 

  1067. <span class="keyword">template</span><span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">CompatibleKey</span> <span class="special">&gt;</span>
    1068. 

  1068. <span class="keyword">const</span> <span class="identifier">info_type</span> <span class="special">&amp;</span> <span class="identifier">info_at</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CompatibleKey</span> <span class="special">&amp;</span> <span class="identifier">k</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
    1069. 

  1069. </pre>
    1070. 

  1070. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    1071. 

  1071. <li class="listitem">
    1072. 

  1072.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">CompatibleKey</span></code>
    1073. 

  1073.                 is a compatible key of <code class="computeroutput"><span class="identifier">key_compare</span></code>.
    1074. 

  1074.               </li>
    1075. 

  1075. <li class="listitem">
    1076. 

  1076.                 <span class="bold"><strong>Effects:</strong></span> Returns the <code class="computeroutput"><span class="identifier">info_type</span></code> reference that is associated
    1077. 

  1077.                 with <code class="computeroutput"><span class="identifier">k</span></code>, or throws
    1078. 

  1078.                 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">out_of_range</span></code> if such key does not
    1079. 

  1079.                 exist.
    1080. 

  1080.               </li>
    1081. 

  1081. <li class="listitem">
    1082. 

  1082.                 <span class="bold"><strong>Complexity:</strong></span> Average case O(1) (constant),
    1083. 

  1083.                 worst case O(n).
    1084. 

  1084.               </li>
    1085. 

  1085. <li class="listitem">
    1086. 

  1086.                 <span class="bold"><strong>Note:</strong></span> Only provided when <code class="computeroutput"><span class="identifier">unordered_set_of</span></code> and <code class="computeroutput"><span class="identifier">info_hook</span></code> are used
    1087. 

  1087.               </li>
    1088. 

  1088. </ul></div>
    1089. 

  1089. </div>
    1090. 

  1090. <div class="section">
    1091. 

  1091. <div class="titlepage"><div><div><h5 class="title">
    1092. 

  1092. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.hash_policy" title="Hash policy">Hash
    1093. 

  1093.           policy</a>
    1094. 

  1094. </h5></div></div></div>
    1095. 

  1095. <a name="reference_unordered_set_of_rehash_size"></a><pre class="programlisting"><span class="keyword">void</span> <span class="identifier">rehash</span><span class="special">(</span><span class="identifier">size_type</span> <span class="identifier">n</span><span class="special">);</span>
    1096. 

  1096. </pre>
    1097. 

  1097. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    1098. 

  1098. <li class="listitem">
    1099. 

  1099.                 <span class="bold"><strong>Effects:</strong></span> Increases if necessary
    1100. 

  1100.                 the number of internal buckets so that <code class="computeroutput"><span class="identifier">size</span><span class="special">()/</span><span class="identifier">bucket_count</span><span class="special">()</span></code> does not exceed the maximum load
    1101. 

  1101.                 factor, and <code class="computeroutput"><span class="identifier">bucket_count</span><span class="special">()&gt;=</span><span class="identifier">n</span></code>.
    1102. 

  1102.               </li>
    1103. 

  1103. <li class="listitem">
    1104. 

  1104.                 <span class="bold"><strong>Postconditions:</strong></span> Validity of iterators
    1105. 

  1105.                 and references to the elements contained is preserved.
    1106. 

  1106.               </li>
    1107. 

  1107. <li class="listitem">
    1108. 

  1108.                 <span class="bold"><strong>Complexity:</strong></span> Average case O(size()),
    1109. 

  1109.                 worst case O(size(n)2).
    1110. 

  1110.               </li>
    1111. 

  1111. <li class="listitem">
    1112. 

  1112.                 <span class="bold"><strong>Exception safety:</strong></span> Strong.
    1113. 

  1113.               </li>
    1114. 

  1114. </ul></div>
    1115. 

  1115. </div>
    1116. 

  1116. <div class="section">
    1117. 

  1117. <div class="titlepage"><div><div><h5 class="title">
    1118. 

  1118. <a name="boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization"></a><a class="link" href="unordered_set_of_reference.html#boost_bimap.reference.unordered_set_of_reference.unordered___multi__set_of_views.serialization" title="Serialization">Serialization</a>
    1119. 

  1119. </h5></div></div></div>
    1120. 

  1120. <p>
    1121. 

  1121.             Views cannot be serialized on their own, but only as part of the <code class="computeroutput"><span class="identifier">bimap</span></code> into which they are embedded.
    1122. 

  1122.             In describing the additional preconditions and guarantees associated
    1123. 

  1123.             to <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code> views with respect to serialization
    1124. 

  1124.             of their embedding containers, we use the concepts defined in the <code class="computeroutput"><span class="identifier">bimap</span></code> serialization section.
    1125. 

  1125.           </p>
    1126. 

  1126. <div class="blurb">
    1127. 

  1127. <div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
    1128. 

  1128. <p>
    1129. 

  1129.             <span class="bold"><strong>Operation:</strong></span> saving of a <code class="computeroutput"><span class="identifier">bimap</span></code> b to an output archive (XML archive)
    1130. 

  1130.             ar.
    1131. 

  1131.           </p>
    1132. 

  1132. </div>
    1133. 

  1133. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
    1134. 

  1134.                 <span class="bold"><strong>Requires:</strong></span> No additional requirements
    1135. 

  1135.                 to those imposed by the container.
    1136. 

  1136.               </li></ul></div>
    1137. 

  1137. <div class="blurb">
    1138. 

  1138. <div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
    1139. 

  1139. <p>
    1140. 

  1140.             <span class="bold"><strong>Operation:</strong></span> loading of a <code class="computeroutput"><span class="identifier">bimap</span></code> b' from an input archive (XML
    1141. 

  1141.             archive) ar.
    1142. 

  1142.           </p>
    1143. 

  1143. </div>
    1144. 

  1144. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    1145. 

  1145. <li class="listitem">
    1146. 

  1146.                 <span class="bold"><strong>Requires:</strong></span> Additionally to the general
    1147. 

  1147.                 requirements, <code class="computeroutput"><span class="identifier">key_eq</span><span class="special">()</span></code> must be serialization-compatible
    1148. 

  1148.                 with <code class="computeroutput"><span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">key_eq</span><span class="special">()</span></code>,
    1149. 

  1149.                 where i is the position of the <code class="computeroutput"><span class="identifier">unordered_</span><span class="special">[</span><span class="identifier">multi</span><span class="special">]</span><span class="identifier">set_of</span></code>
    1150. 

  1150.                 view in the container.
    1151. 

  1151.               </li>
    1152. 

  1152. <li class="listitem">
    1153. 

  1153.                 <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
    1154. 

  1154.                 the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">end</span><span class="special">())</span></code> contains restored copies of every
    1155. 

  1155.                 element in <code class="computeroutput"><span class="special">[</span><span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">())</span></code>, though not necessarily in the
    1156. 

  1156.                 same order.
    1157. 

  1157.               </li>
    1158. 

  1158. </ul></div>
    1159. 

  1159. <div class="blurb">
    1160. 

  1160. <div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
    1161. 

  1161. <p>
    1162. 

  1162.             <span class="bold"><strong>Operation:</strong></span> saving of an <code class="computeroutput"><span class="identifier">iterator</span></code> or <code class="computeroutput"><span class="identifier">const_iterator</span></code>
    1163. 

  1163.             <code class="computeroutput"><span class="identifier">it</span></code> to an output archive
    1164. 

  1164.             (XML archive) ar.
    1165. 

  1165.           </p>
    1166. 

  1166. </div>
    1167. 

  1167. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
    1168. 

  1168.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">it</span></code>
    1169. 

  1169.                 is a valid <code class="computeroutput"><span class="identifier">iterator</span></code>
    1170. 

  1170.                 of the view. The associated <code class="computeroutput"><span class="identifier">bimap</span></code>
    1171. 

  1171.                 has been previously saved.
    1172. 

  1172.               </li></ul></div>
    1173. 

  1173. <div class="blurb">
    1174. 

  1174. <div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
    1175. 

  1175. <p>
    1176. 

  1176.             <span class="bold"><strong>Operation:</strong></span> loading of an iterator or
    1177. 

  1177.             <code class="computeroutput"><span class="identifier">const_iterator</span> <span class="identifier">it</span></code>'
    1178. 

  1178.             from an input archive (XML archive) ar.
    1179. 

  1179.           </p>
    1180. 

  1180. </div>
    1181. 

  1181. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    1182. 

  1182. <li class="listitem">
    1183. 

  1183.                 <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
    1184. 

  1184.                 if <code class="computeroutput"><span class="identifier">it</span></code> was dereferenceable
    1185. 

  1185.                 then <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>'
    1186. 

  1186.                 is the restored copy of <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>, otherwise <code class="computeroutput"><span class="identifier">it</span></code>'<code class="computeroutput">
    1187. 

  1187.                 <span class="special">==</span> <span class="identifier">end</span><span class="special">()</span></code>.
    1188. 

  1188.               </li>
    1189. 

  1189. <li class="listitem">
    1190. 

  1190.                 <span class="bold"><strong>Note:</strong></span> It is allowed that <code class="computeroutput"><span class="identifier">it</span></code> be a <code class="computeroutput"><span class="identifier">const_iterator</span></code>
    1191. 

  1191.                 and the restored <code class="computeroutput"><span class="identifier">it</span></code>'
    1192. 

  1192.                 an <code class="computeroutput"><span class="identifier">iterator</span></code>, or viceversa.
    1193. 

  1193.               </li>
    1194. 

  1194. </ul></div>
    1195. 

  1195. <div class="blurb">
    1196. 

  1196. <div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
    1197. 

  1197. <p>
    1198. 

  1198.             <span class="bold"><strong>Operation:</strong></span> saving of a local_iterator
    1199. 

  1199.             or const_local_iterator it to an output archive (XML archive) ar.
    1200. 

  1200.           </p>
    1201. 

  1201. </div>
    1202. 

  1202. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
    1203. 

  1203.                 <span class="bold"><strong>Requires: </strong></span> <code class="computeroutput"><span class="identifier">it</span></code>
    1204. 

  1204.                 is a valid local iterator of the view. The associated <code class="computeroutput"><span class="identifier">bimap</span></code> has been previously saved.
    1205. 

  1205.               </li></ul></div>
    1206. 

  1206. <div class="blurb">
    1207. 

  1207. <div class="titlepage"><div><div><p class="title"><b></b></p></div></div></div>
    1208. 

  1208. <p>
    1209. 

  1209.             <span class="bold"><strong>Operation:</strong></span> loading of a <code class="computeroutput"><span class="identifier">local_iterator</span></code> or <code class="computeroutput"><span class="identifier">const_local_iterator</span></code>
    1210. 

  1210.             <code class="computeroutput"><span class="identifier">it</span></code>' from an input archive
    1211. 

  1211.             (XML archive) ar.
    1212. 

  1212.           </p>
    1213. 

  1213. </div>
    1214. 

  1214. <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
    1215. 

  1215. <li class="listitem">
    1216. 

  1216.                 <span class="bold"><strong>Postconditions:</strong></span> On successful loading,
    1217. 

  1217.                 if <code class="computeroutput"><span class="identifier">it</span></code> was dereferenceable
    1218. 

  1218.                 then <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>'
    1219. 

  1219.                 is the restored copy of <code class="computeroutput"><span class="special">*</span><span class="identifier">it</span></code>; if <code class="computeroutput"><span class="identifier">it</span></code>
    1220. 

  1220.                 was <code class="computeroutput"><span class="identifier">m</span><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code>
    1221. 

  1221.                 for some n, then <code class="computeroutput"><span class="identifier">it</span></code>'<code class="computeroutput">
    1222. 

  1222.                 <span class="special">==</span> <span class="identifier">m</span></code>'<code class="computeroutput"><span class="special">.</span><span class="identifier">get</span><span class="special">&lt;</span><span class="identifier">i</span><span class="special">&gt;().</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code> (where <code class="computeroutput"><span class="identifier">b</span></code>
    1223. 

  1223.                 is the original <code class="computeroutput"><span class="identifier">bimap</span></code>,
    1224. 

  1224.                 <code class="computeroutput"><span class="identifier">b</span></code>' its restored copy
    1225. 

  1225.                 and <code class="computeroutput"><span class="identifier">i</span></code> is the ordinal
    1226. 

  1226.                 of the index.)
    1227. 

  1227.               </li>
    1228. 

  1228. <li class="listitem">
    1229. 

  1229.                 <span class="bold"><strong>Note:</strong></span> It is allowed that <code class="computeroutput"><span class="identifier">it</span></code> be a <code class="computeroutput"><span class="identifier">const_local_iterator</span></code>
    1230. 

  1230.                 and the restored <code class="computeroutput"><span class="identifier">it</span></code>'
    1231. 

  1231.                 a <code class="computeroutput"><span class="identifier">local_iterator</span></code>,
    1232. 

  1232.                 or viceversa.
    1233. 

  1233.               </li>
    1234. 

  1234. </ul></div>
    1235. 

  1235. </div>
    1236. 

  1236. </div>
    1237. 

  1237. </div>
    1238. 

  1238. <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
    1239. 

  1239. <td align="left"></td>
    1240. 

  1240. <td align="right"><div class="copyright-footer">Copyright &#169; 2006-2012 Matias Capeletto<p>
    1241. 

  1241.         Distributed under the Boost Software License, Version 1.0. (See accompanying
    1242. 

  1242.         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
    1243. 

  1243.       </p>
    1244. 

  1244. </div></td>
    1245. 

  1245. </tr></table>
    1246. 

  1246. <hr>
    1247. 

  1247. <div class="spirit-nav">
    1248. 

  1248. <a accesskey="p" href="set_of_reference.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="list_of_reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
    1249. 

  1249. </div>
    1250. 

  1250. </body>
    1251. 

  1251. </html>
    1252.