3 <meta http-equiv=
"Content-Type" content=
"text/html; charset=US-ASCII">
4 <title>set_of Reference
</title>
5 <link rel=
"stylesheet" href=
"../../boostbook.css" type=
"text/css">
6 <meta name=
"generator" content=
"DocBook XSL Stylesheets V1.77.1">
7 <link rel=
"home" href=
"../../index.html" title=
"Chapter 1. Boost.Bimap">
8 <link rel=
"up" href=
"../reference.html" title=
"Reference">
9 <link rel=
"prev" href=
"bimap_reference.html" title=
"Bimap Reference">
10 <link rel=
"next" href=
"unordered_set_of_reference.html" title=
"unordered_set_of Reference">
12 <body bgcolor=
"white" text=
"black" link=
"#0000FF" vlink=
"#840084" alink=
"#0000FF">
13 <table cellpadding=
"2" width=
"100%"><tr>
14 <td valign=
"top"><img alt=
"Boost C++ Libraries" width=
"277" height=
"86" src=
"../../../../../../boost.png"></td>
15 <td align=
"center"><a href=
"../../../../../../index.html">Home
</a></td>
16 <td align=
"center"><a href=
"../../../../../../libs/libraries.htm">Libraries
</a></td>
17 <td align=
"center"><a href=
"http://www.boost.org/users/people.html">People
</a></td>
18 <td align=
"center"><a href=
"http://www.boost.org/users/faq.html">FAQ
</a></td>
19 <td align=
"center"><a href=
"../../../../../../more/index.htm">More
</a></td>
22 <div class=
"spirit-nav">
23 <a accesskey=
"p" href=
"bimap_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=
"unordered_set_of_reference.html"><img src=
"../../../../../../doc/src/images/next.png" alt=
"Next"></a>
25 <div class=
"section boost_bimap_reference_set_of_reference">
26 <div class=
"titlepage"><div><div><h3 class=
"title">
27 <a name=
"boost_bimap.reference.set_of_reference"></a><a class=
"link" href=
"set_of_reference.html" title=
"set_of Reference">set_of Reference
</a>
28 </h3></div></div></div>
30 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.header__boost_bimap_set_of_hpp__synopsis">Header
31 "boost/bimap/set_of.hpp" synopsis
</a></span></dt>
32 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.header__boost_bimap_multiset_of_hpp__synopsis">Header
33 "boost/bimap/multiset_of.hpp" synopsis
</a></span></dt>
34 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.collection_type_specifiers_set_of_and_multiset_of">Collection
35 type specifiers set_of and multiset_of
</a></span></dt>
36 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views">[multi]set_of
39 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.complexity_signature">Complexity
40 signature
</a></span></dt>
41 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.instantiation_types">Instantiation
43 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.constructors__copy_and_assignment">Constructors,
44 copy and assignment
</a></span></dt>
45 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.modifiers">Modifiers
</a></span></dt>
46 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.set_operations">Set
47 operations
</a></span></dt>
48 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.range_operations">Range
49 operations
</a></span></dt>
50 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.at____info_at___and_operator_______set_of_only">at(),
51 info_at() and operator[] - set_of only
</a></span></dt>
52 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.serialization">Serialization
</a></span></dt>
55 <div class=
"section boost_bimap_reference_set_of_reference_header__boost_bimap_set_of_hpp__synopsis">
56 <div class=
"titlepage"><div><div><h4 class=
"title">
57 <a name=
"boost_bimap.reference.set_of_reference.header__boost_bimap_set_of_hpp__synopsis"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.header__boost_bimap_set_of_hpp__synopsis" title='Header
"boost/bimap/set_of.hpp" synopsis'
>Header
58 "boost/bimap/set_of.hpp" synopsis
</a>
59 </h4></div></div></div>
60 <pre class=
"programlisting"><span class=
"keyword">namespace
</span> <span class=
"identifier">boost
</span> <span class=
"special">{
</span>
61 <span class=
"keyword">namespace
</span> <span class=
"identifier">bimaps
</span> <span class=
"special">{
</span>
64 <span class=
"keyword">template
</span>
65 <span class=
"special"><</span>
66 <span class=
"keyword">class
</span> <span class=
"identifier">KeyType
</span><span class=
"special">,
</span>
67 <span class=
"keyword">class
</span> <span class=
"identifier">KeyCompare
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">less
</span><span class=
"special"><</span> <span class=
"identifier">KeyType
</span> <span class=
"special">></span>
68 <span class=
"special">></span>
69 <span class=
"keyword">struct
</span> <span class=
"identifier">set_of
</span><span class=
"special">;
</span>
72 <span class=
"keyword">template
</span>
73 <span class=
"special"><</span>
74 <span class=
"keyword">class
</span> <span class=
"identifier">KeyCompare
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">less
</span><span class=
"special"><</span> <span class=
"identifier">_relation
</span> <span class=
"special">></span>
75 <span class=
"special">></span>
76 <span class=
"keyword">struct
</span> <span class=
"identifier">set_of_relation
</span><span class=
"special">;
</span>
79 <span class=
"special">}
</span> <span class=
"comment">// namespace bimap
</span>
80 <span class=
"special">}
</span> <span class=
"comment">// namespace boost
</span>
83 <div class=
"section boost_bimap_reference_set_of_reference_header__boost_bimap_multiset_of_hpp__synopsis">
84 <div class=
"titlepage"><div><div><h4 class=
"title">
85 <a name=
"boost_bimap.reference.set_of_reference.header__boost_bimap_multiset_of_hpp__synopsis"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.header__boost_bimap_multiset_of_hpp__synopsis" title='Header
"boost/bimap/multiset_of.hpp" synopsis'
>Header
86 "boost/bimap/multiset_of.hpp" synopsis
</a>
87 </h4></div></div></div>
88 <pre class=
"programlisting"><span class=
"keyword">namespace
</span> <span class=
"identifier">boost
</span> <span class=
"special">{
</span>
89 <span class=
"keyword">namespace
</span> <span class=
"identifier">bimaps
</span> <span class=
"special">{
</span>
92 <span class=
"keyword">template
</span>
93 <span class=
"special"><</span>
94 <span class=
"keyword">class
</span> <span class=
"identifier">KeyType
</span><span class=
"special">,
</span>
95 <span class=
"keyword">class
</span> <span class=
"identifier">KeyCompare
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">less
</span><span class=
"special"><</span> <span class=
"identifier">KeyType
</span> <span class=
"special">></span>
96 <span class=
"special">></span>
97 <span class=
"keyword">struct
</span> <span class=
"identifier">multiset_of
</span><span class=
"special">;
</span>
100 <span class=
"keyword">template
</span>
101 <span class=
"special"><</span>
102 <span class=
"keyword">class
</span> <span class=
"identifier">KeyCompare
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">less
</span><span class=
"special"><</span> <span class=
"identifier">_relation
</span> <span class=
"special">></span>
103 <span class=
"special">></span>
104 <span class=
"keyword">struct
</span> <span class=
"identifier">multiset_of_relation
</span><span class=
"special">;
</span>
107 <span class=
"special">}
</span> <span class=
"comment">// namespace bimap
</span>
108 <span class=
"special">}
</span> <span class=
"comment">// namespace boost
</span>
111 <div class=
"section boost_bimap_reference_set_of_reference_collection_type_specifiers_set_of_and_multiset_of">
112 <div class=
"titlepage"><div><div><h4 class=
"title">
113 <a name=
"boost_bimap.reference.set_of_reference.collection_type_specifiers_set_of_and_multiset_of"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.collection_type_specifiers_set_of_and_multiset_of" title=
"Collection type specifiers set_of and multiset_of">Collection
114 type specifiers set_of and multiset_of
</a>
115 </h4></div></div></div>
117 These collection type specifiers allow for insertion of sets disallowing
118 or allowing duplicate elements, respectively. The syntaxes of
<code class=
"computeroutput"><span class=
"identifier">set_of
</span></code> and
<code class=
"computeroutput"><span class=
"identifier">multiset_of
</span></code>
119 coincide, so they are described together.
122 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views">
123 <div class=
"titlepage"><div><div><h4 class=
"title">
124 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views" title=
"[multi]set_of Views">[multi]set_of
126 </h4></div></div></div>
127 <div class=
"toc"><dl>
128 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.complexity_signature">Complexity
129 signature
</a></span></dt>
130 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.instantiation_types">Instantiation
131 types
</a></span></dt>
132 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.constructors__copy_and_assignment">Constructors,
133 copy and assignment
</a></span></dt>
134 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.modifiers">Modifiers
</a></span></dt>
135 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.set_operations">Set
136 operations
</a></span></dt>
137 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.range_operations">Range
138 operations
</a></span></dt>
139 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.at____info_at___and_operator_______set_of_only">at(),
140 info_at() and operator[] - set_of only
</a></span></dt>
141 <dt><span class=
"section"><a href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.serialization">Serialization
</a></span></dt>
144 A [multi]set_of set view is a std::[multi]set signature-compatible interface
145 to the underlying heap of elements contained in a
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
148 There are two variants: set_of, which does not allow duplicate elements
149 (with respect to its associated comparison predicate) and multiset_of,
150 which does accept those duplicates. The interface of these two variants
151 is largely the same, so they are documented together with their differences
152 explicitly noted where they exist.
155 If you look the bimap from a side, you will use a map view, and if you
156 look at it as a whole, you will be using a set view.
158 <pre class=
"programlisting"> <span class=
"keyword">namespace
</span> <span class=
"identifier">boost
</span> <span class=
"special">{
</span>
159 <span class=
"keyword">namespace
</span> <span class=
"identifier">bimaps
</span> <span class=
"special">{
</span>
160 <span class=
"keyword">namespace
</span> <span class=
"identifier">views
</span> <span class=
"special">{
</span>
162 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"emphasis"><em>-implementation defined parameter list-
</em></span> <span class=
"special">></span>
163 <span class=
"keyword">class
</span> <span class=
"emphasis"><em>-implementation defined view name-
</em></span>
164 <span class=
"special">{
</span>
165 <span class=
"keyword">public
</span><span class=
"special">:
</span>
167 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">key_type
</span><span class=
"special">;
</span>
168 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">value_type
</span><span class=
"special">;
</span>
169 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">key_compare
</span><span class=
"special">;
</span>
170 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">value_compare
</span><span class=
"special">;
</span>
171 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">allocator_type
</span><span class=
"special">;
</span>
172 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">reference
</span><span class=
"special">;
</span>
173 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">const_reference
</span><span class=
"special">;
</span>
174 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">iterator
</span><span class=
"special">;
</span>
175 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">const_iterator
</span><span class=
"special">;
</span>
176 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">size_type
</span><span class=
"special">;
</span>
177 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">difference_type
</span><span class=
"special">;
</span>
178 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">pointer
</span><span class=
"special">;
</span>
179 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">const_pointer
</span><span class=
"special">;
</span>
180 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">reverse_iterator
</span><span class=
"special">;
</span>
181 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">const_reverse_iterator
</span><span class=
"special">;
</span>
183 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">info_type
</span><span class=
"special">;
</span>
185 <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"keyword">operator
</span><span class=
"special">=(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
187 <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>
189 <span class=
"comment">// iterators
</span>
191 <span class=
"identifier">iterator
</span> <span class=
"identifier">begin
</span><span class=
"special">();
</span>
192 <span class=
"identifier">const_iterator
</span> <span class=
"identifier">begin
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
194 <span class=
"identifier">iterator
</span> <span class=
"identifier">end
</span><span class=
"special">();
</span>
195 <span class=
"identifier">const_iterator
</span> <span class=
"identifier">end
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
197 <span class=
"identifier">reverse_iterator
</span> <span class=
"identifier">rbegin
</span><span class=
"special">();
</span>
198 <span class=
"identifier">const_reverse_iterator
</span> <span class=
"identifier">rbegin
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
200 <span class=
"identifier">reverse_iterator
</span> <span class=
"identifier">rend
</span><span class=
"special">();
</span>
201 <span class=
"identifier">const_reverse_iterator
</span> <span class=
"identifier">rend
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
203 <span class=
"comment">// capacity
</span>
205 <span class=
"keyword">bool
</span> <span class=
"identifier">empty
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
207 <span class=
"identifier">size_type
</span> <span class=
"identifier">size
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
209 <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>
211 <span class=
"comment">// modifiers
</span>
213 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">iterator
</span><span class=
"special">,
</span><span class=
"keyword">bool
</span><span class=
"special">></span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_insert_value">insert
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">value_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
215 <span class=
"identifier">iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
217 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">InputIterator
</span><span class=
"special">></span>
218 <span class=
"keyword">void
</span> <a class=
"link" href=
"set_of_reference.html#reference_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>
220 <span class=
"identifier">iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_erase_iterator">erase
</a><span class=
"special">(
</span><span class=
"identifier">iterator
</span> <span class=
"identifier">position
</span><span class=
"special">);
</span>
222 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
223 <span class=
"identifier">size_type
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_erase_key">erase
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
225 <span class=
"identifier">iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_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>
227 <span class=
"keyword">bool
</span> <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
229 <span class=
"comment">// Only in map views
</span>
230 <span class=
"comment">// {
</span>
232 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
233 <span class=
"keyword">bool
</span> <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
235 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleData
</span> <span class=
"special">></span>
236 <span class=
"keyword">bool
</span> <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
238 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">KeyModifier
</span> <span class=
"special">></span>
239 <span class=
"keyword">bool
</span> <a class=
"link" href=
"set_of_reference.html#reference_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>
241 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">DataModifier
</span> <span class=
"special">></span>
242 <span class=
"keyword">bool
</span> <a class=
"link" href=
"set_of_reference.html#reference_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>
244 <span class=
"comment">// }
</span>
246 <span class=
"keyword">void
</span> <span class=
"identifier">swap
</span><span class=
"special">(
</span><span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
248 <span class=
"keyword">void
</span> <span class=
"identifier">clear
</span><span class=
"special">();
</span>
250 <span class=
"comment">// observers
</span>
252 <span class=
"identifier">key_compare
</span> <span class=
"identifier">key_comp
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
254 <span class=
"identifier">value_compare
</span> <span class=
"identifier">value_comp
</span><span class=
"special">()
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
256 <span class=
"comment">// set operations
</span>
258 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
259 <span class=
"identifier">iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_find_key">find
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
261 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
262 <span class=
"identifier">const_iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_find_key">find
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
265 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
266 <span class=
"identifier">size_type
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_count_key">count
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
269 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
270 <span class=
"identifier">iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_lower_bound_key">lower_bound
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
272 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
273 <span class=
"identifier">const_iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_lower_bound_key">lower_bound
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
276 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
277 <span class=
"identifier">iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_upper_bound_key">upper_bound
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
279 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
280 <span class=
"identifier">const_iterator
</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_upper_bound_key">upper_bound
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
283 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
284 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">iterator
</span><span class=
"special">,
</span><span class=
"identifier">iterator
</span><span class=
"special">></span>
285 <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
287 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
288 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">const_iterator
</span><span class=
"special">,
</span><span class=
"identifier">const_iterator
</span><span class=
"special">></span>
289 <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
291 <span class=
"comment">// Only in maps views
</span>
292 <span class=
"comment">// {
</span>
294 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">LowerBounder
</span><span class=
"special">,
</span> <span class=
"keyword">class
</span> <span class=
"identifier">UpperBounder
</span><span class=
"special">></span>
295 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">iterator
</span><span class=
"special">,
</span><span class=
"identifier">iterator
</span><span class=
"special">></span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_range_lower_upper">range
</a><span class=
"special">(
</span>
296 <span class=
"identifier">LowerBounder
</span> <span class=
"identifier">lower
</span><span class=
"special">,
</span> <span class=
"identifier">UpperBounder
</span> <span class=
"identifier">upper
</span><span class=
"special">);
</span>
298 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">LowerBounder
</span><span class=
"special">,
</span> <span class=
"keyword">class
</span> <span class=
"identifier">UpperBounder
</span><span class=
"special">></span>
299 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">const_iterator
</span><span class=
"special">,
</span><span class=
"identifier">const_iterator
</span><span class=
"special">></span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_range_lower_upper">range
</a><span class=
"special">(
</span>
300 <span class=
"identifier">LowerBounder
</span> <span class=
"identifier">lower
</span><span class=
"special">,
</span> <span class=
"identifier">UpperBounder
</span> <span class=
"identifier">upper
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
302 <span class=
"keyword">typedef
</span> <span class=
"emphasis"><em>-unspecified-
</em></span> <span class=
"identifier">mapped_type
</span><span class=
"special">;
</span>
303 <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>
305 <span class=
"comment">// Only in for `set_of` collection type
</span>
306 <span class=
"comment">// {
</span>
308 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
309 <span class=
"keyword">const
</span> <span class=
"identifier">mapped_type
</span> <span class=
"special">&</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_at_key_const">at
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
311 <span class=
"comment">// Only if the other collection type is mutable
</span>
312 <span class=
"comment">// {
</span>
314 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
315 <span class=
"identifier">mapped_type
</span> <span class=
"special">&</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_operator_bracket_key">operator[]
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">);
</span>
317 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
318 <span class=
"identifier">mapped_type
</span> <span class=
"special">&</span> <a class=
"link" href=
"set_of_reference.html#reference_set_of_at_key">at
</a><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">);
</span>
320 <span class=
"comment">// }
</span>
322 <span class=
"comment">// Only if info_hook is used
</span>
323 <span class=
"comment">// {
</span>
325 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
326 <span class=
"identifier">info_type
</span> <span class=
"special">&</span> <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">k
</span><span class=
"special">);
</span>
328 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
329 <span class=
"keyword">const
</span> <span class=
"identifier">info_type
</span> <span class=
"special">&</span> <a class=
"link" href=
"set_of_reference.html#reference_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">&</span> <span class=
"identifier">k
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
331 <span class=
"comment">// }
</span>
333 <span class=
"comment">// }
</span>
335 <span class=
"comment">// }
</span>
336 <span class=
"special">};
</span>
338 <span class=
"comment">// view comparison
</span>
340 <span class=
"keyword">bool
</span> <span class=
"keyword">operator
</span><span class=
"special">==(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v1
</span><span class=
"special">,
</span> <span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v2
</span> <span class=
"special">);
</span>
341 <span class=
"keyword">bool
</span> <span class=
"keyword">operator
</span><span class=
"special"><</span> <span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v1
</span><span class=
"special">,
</span> <span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v2
</span> <span class=
"special">);
</span>
342 <span class=
"keyword">bool
</span> <span class=
"keyword">operator
</span><span class=
"special">!=(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v1
</span><span class=
"special">,
</span> <span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v2
</span> <span class=
"special">);
</span>
343 <span class=
"keyword">bool
</span> <span class=
"keyword">operator
</span><span class=
"special">></span> <span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v1
</span><span class=
"special">,
</span> <span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v2
</span> <span class=
"special">);
</span>
344 <span class=
"keyword">bool
</span> <span class=
"keyword">operator
</span><span class=
"special">>=(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v1
</span><span class=
"special">,
</span> <span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v2
</span> <span class=
"special">);
</span>
345 <span class=
"keyword">bool
</span> <span class=
"keyword">operator
</span><span class=
"special"><=(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v1
</span><span class=
"special">,
</span> <span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">v2
</span> <span class=
"special">);
</span>
347 <span class=
"special">}
</span> <span class=
"comment">// namespace views
</span>
348 <span class=
"special">}
</span> <span class=
"comment">// namespace bimap
</span>
349 <span class=
"special">}
</span> <span class=
"comment">// namespace boost
</span>
352 In the case of a
<code class=
"computeroutput"><span class=
"identifier">bimap
</span><span class=
"special"><</span> <span class=
"special">{
</span><span class=
"identifier">multi
</span><span class=
"special">}
</span><span class=
"identifier">set_of
</span><span class=
"special"><</span><span class=
"identifier">Left
</span><span class=
"special">>,
</span> <span class=
"special">...
</span> <span class=
"special">></span></code>
357 <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"><</span> <span class=
"identifier">Left
</span><span class=
"special">,
</span> <span class=
"special">...
</span> <span class=
"special">></span> <span class=
"identifier">key_type
</span><span class=
"special">;
</span>
358 <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"><</span> <span class=
"keyword">const
</span> <span class=
"identifier">Left
</span><span class=
"special">,
</span> <span class=
"special">...
</span> <span class=
"special">></span> <span class=
"identifier">value_type
</span><span class=
"special">;
</span>
361 In the left map view:
363 <pre class=
"programlisting"><span class=
"keyword">typedef
</span> <span class=
"identifier">Left
</span> <span class=
"identifier">key_type
</span><span class=
"special">;
</span>
364 <span class=
"keyword">typedef
</span> <span class=
"special">...
</span> <span class=
"identifier">mapped_type
</span><span class=
"special">;
</span>
366 <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"><</span> <span class=
"keyword">const
</span> <span class=
"identifier">Left
</span><span class=
"special">,
</span> <span class=
"special">...
</span> <span class=
"special">></span> <span class=
"identifier">value_type
</span><span class=
"special">;
</span>
369 In the right map view:
371 <pre class=
"programlisting"><span class=
"keyword">typedef
</span> <span class=
"special">...
</span> <span class=
"identifier">key_type
</span><span class=
"special">;
</span>
372 <span class=
"keyword">typedef
</span> <span class=
"identifier">Left
</span> <span class=
"identifier">mapped_type
</span><span class=
"special">;
</span>
374 <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"><</span> <span class=
"special">...
</span> <span class=
"special">,
</span><span class=
"keyword">const
</span> <span class=
"identifier">Left
</span> <span class=
"special">></span> <span class=
"identifier">value_type
</span><span class=
"special">;
</span>
376 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_complexity_signature">
377 <div class=
"titlepage"><div><div><h5 class=
"title">
378 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.complexity_signature"></a><a name=
"set_of_complexity_signature"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.complexity_signature" title=
"Complexity signature">Complexity
380 </h5></div></div></div>
382 Here and in the descriptions of operations of this view, we adopt the
383 scheme outlined in the
<a class=
"link" href=
"bimap_reference.html#complexity_signature_explanation">complexity
384 signature section
</a>. The complexity signature of [multi]set_of view
387 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
388 <li class=
"listitem">
389 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>,
391 <li class=
"listitem">
392 insertion:
<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">log
</span><span class=
"special">(
</span><span class=
"identifier">n
</span><span class=
"special">)
</span></code>,
394 <li class=
"listitem">
395 hinted insertion:
<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) if the hint element precedes
396 the point of insertion,
<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">log
</span><span class=
"special">(
</span><span class=
"identifier">n
</span><span class=
"special">)
</span></code>
399 <li class=
"listitem">
400 deletion:
<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>
401 (amortized constant),
403 <li class=
"listitem">
404 replacement:
<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> <span class=
"number">1</span></code>
405 (constant) if the element position does not change,
<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> <span class=
"identifier">log
</span><span class=
"special">(
</span><span class=
"identifier">n
</span><span class=
"special">)
</span></code> otherwise,
407 <li class=
"listitem">
408 modifying:
<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>
409 (constant) if the element position does not change,
<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">log
</span><span class=
"special">(
</span><span class=
"identifier">n
</span><span class=
"special">)
</span></code> otherwise.
413 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_instantiation_types">
414 <div class=
"titlepage"><div><div><h5 class=
"title">
415 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.instantiation_types"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.instantiation_types" title=
"Instantiation types">Instantiation
417 </h5></div></div></div>
419 Set views are instantiated internally to a
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
420 Instantiations are dependent on the following types:
422 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
423 <li class=
"listitem">
424 <code class=
"computeroutput"><span class=
"identifier">Value
</span></code> from the set
427 <li class=
"listitem">
428 <code class=
"computeroutput"><span class=
"identifier">Allocator
</span></code> from
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>,
430 <li class=
"listitem">
431 <code class=
"computeroutput"><span class=
"identifier">Compare
</span></code> from the
436 <code class=
"computeroutput"><span class=
"identifier">Compare
</span></code> is a
<a href=
"http://www.sgi.com/tech/stl/StrictWeakOrdering.html" target=
"_top">Strict
437 Weak Ordering
</a> on elements of
<code class=
"computeroutput"><span class=
"identifier">Value
</span></code>.
440 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_constructors__copy_and_assignment">
441 <div class=
"titlepage"><div><div><h5 class=
"title">
442 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.constructors__copy_and_assignment"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.constructors__copy_and_assignment" title=
"Constructors, copy and assignment">Constructors,
443 copy and assignment
</a>
444 </h5></div></div></div>
446 Set views do not have public constructors or destructors. Assignment,
447 on the other hand, is provided.
449 <pre class=
"programlisting"><span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"keyword">operator
</span><span class=
"special">=(
</span><span class=
"keyword">const
</span> <span class=
"identifier">this_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
451 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
452 <li class=
"listitem">
453 <span class=
"bold"><strong>Effects:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">a
</span>
454 <span class=
"special">=
</span> <span class=
"identifier">b
</span><span class=
"special">;
</span></code> where a and b are the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> objects to which
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"keyword">this
</span></code>
455 and x belong, respectively.
457 <li class=
"listitem">
458 <span class=
"bold"><strong>Returns:
</strong></span> <code class=
"computeroutput"><span class=
"special">*
</span><span class=
"keyword">this
</span></code>.
462 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_modifiers">
463 <div class=
"titlepage"><div><div><h5 class=
"title">
464 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.modifiers"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.modifiers" title=
"Modifiers">Modifiers
</a>
465 </h5></div></div></div>
466 <a name=
"reference_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"><</span><span class=
"identifier">iterator
</span><span class=
"special">,
</span><span class=
"keyword">bool
</span><span class=
"special">></span> <span class=
"identifier">insert
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">value_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
468 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
469 <li class=
"listitem">
470 <span class=
"bold"><strong>Effects:
</strong></span> Inserts
<code class=
"computeroutput"><span class=
"identifier">x
</span></code>
471 into the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> to
472 which the set view belongs if
473 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: circle; ">
474 <li class=
"listitem">
475 the set view is non-unique OR no other element with equivalent
478 <li class=
"listitem">
479 AND insertion is allowed by the other set specifications the
480 <code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
484 <li class=
"listitem">
485 <span class=
"bold"><strong>Returns:
</strong></span> The return value is a pair
486 <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>
487 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;
488 otherwise,
<code class=
"computeroutput"><span class=
"identifier">p
</span><span class=
"special">.
</span><span class=
"identifier">first
</span></code> points to an element that
489 caused the insertion to be banned. Note that more than one element
490 can be causing insertion not to be allowed.
492 <li class=
"listitem">
493 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
496 <li class=
"listitem">
497 <span class=
"bold"><strong>Exception safety:
</strong></span> Strong.
500 <a name=
"reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
502 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
503 <li class=
"listitem">
504 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">position
</span></code>
505 is a valid iterator of the view.
507 <li class=
"listitem">
508 <span class=
"bold"><strong>Effects:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">position
</span></code>
509 is used as a hint to improve the efficiency of the operation. Inserts
510 <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
512 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: circle; ">
513 <li class=
"listitem">
514 the set view is non-unique OR no other element with equivalent
517 <li class=
"listitem">
518 AND insertion is allowed by all other views of the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
522 <li class=
"listitem">
523 <span class=
"bold"><strong>Returns:
</strong></span> On successful insertion,
524 an iterator to the newly inserted element. Otherwise, an iterator
525 to an element that caused the insertion to be banned. Note that more
526 than one element can be causing insertion not to be allowed.
528 <li class=
"listitem">
529 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
532 <li class=
"listitem">
533 <span class=
"bold"><strong>Exception safety:
</strong></span> Strong.
536 <a name=
"reference_set_of_insert_iterator_iterator"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">InputIterator
</span> <span class=
"special">></span>
537 <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>
539 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
540 <li class=
"listitem">
541 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">InputIterator
</span></code>
542 is a model of
<a href=
"http://www.sgi.com/tech/stl/InputIterator.html" target=
"_top">Input
543 Iterator
</a> over elements of type
<code class=
"computeroutput"><span class=
"identifier">value_type
</span></code>
544 or a type convertible to value_type.
<code class=
"computeroutput"><span class=
"identifier">first
</span></code>
545 and
<code class=
"computeroutput"><span class=
"identifier">last
</span></code> are not
546 iterators into any view of the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>
547 to which this index belongs.
<code class=
"computeroutput"><span class=
"identifier">last
</span></code>
548 is reachable from
<code class=
"computeroutput"><span class=
"identifier">first
</span></code>.
550 <li class=
"listitem">
551 <span class=
"bold"><strong>Effects:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">iterator
</span>
552 <span class=
"identifier">hint
</span> <span class=
"special">=
</span>
553 <span class=
"identifier">end
</span><span class=
"special">()
</span></code>;
554 <code class=
"computeroutput"><span class=
"keyword">while
</span><span class=
"special">(
</span>
555 <span class=
"identifier">first
</span> <span class=
"special">!=
</span>
556 <span class=
"identifier">last
</span> <span class=
"special">)
</span>
557 <span class=
"identifier">hint
</span> <span class=
"special">=
</span>
558 <span class=
"identifier">insert
</span><span class=
"special">(
</span>
559 <span class=
"identifier">hint
</span><span class=
"special">,
</span>
560 <span class=
"special">*
</span><span class=
"identifier">first
</span><span class=
"special">++
</span> <span class=
"special">);
</span></code>
562 <li class=
"listitem">
563 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
564 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>
565 <span class=
"identifier">last
</span><span class=
"special">)
</span></code>.
567 <li class=
"listitem">
568 <span class=
"bold"><strong>Exception safety:
</strong></span> Basic.
571 <a name=
"reference_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>
573 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
574 <li class=
"listitem">
575 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">position
</span></code>
576 is a valid dereferenceable iterator if the set view.
578 <li class=
"listitem">
579 <span class=
"bold"><strong>Effects:
</strong></span> Deletes the element pointed
580 to by
<code class=
"computeroutput"><span class=
"identifier">position
</span></code>.
582 <li class=
"listitem">
583 <span class=
"bold"><strong>Returns:
</strong></span> An iterator pointing to
584 the element immediately following the one that was deleted, or
<code class=
"computeroutput"><span class=
"identifier">end
</span><span class=
"special">()
</span></code>
585 if no such element exists.
587 <li class=
"listitem">
588 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
591 <li class=
"listitem">
592 <span class=
"bold"><strong>Exception safety:
</strong></span> nothrow.
595 <a name=
"reference_set_of_erase_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
596 <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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
598 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
599 <li class=
"listitem">
600 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
601 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
603 <li class=
"listitem">
604 <span class=
"bold"><strong>Effects:
</strong></span> Deletes the elements with
605 key equivalent to
<code class=
"computeroutput"><span class=
"identifier">x
</span></code>.
607 <li class=
"listitem">
608 <span class=
"bold"><strong>Returns:
</strong></span> Number of elements deleted.
610 <li class=
"listitem">
611 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
612 O(log(n) + m*D(n)), where m is the number of elements deleted.
614 <li class=
"listitem">
615 <span class=
"bold"><strong>Exception safety:
</strong></span> Basic.
618 <a name=
"reference_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>
620 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
621 <li class=
"listitem">
622 <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>
623 is a valid range of the view.
625 <li class=
"listitem">
626 <span class=
"bold"><strong>Effects:
</strong></span> Deletes the elements in
627 <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>.
629 <li class=
"listitem">
630 <span class=
"bold"><strong>Returns:
</strong></span> last.
632 <li class=
"listitem">
633 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
634 O(log(n) + 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>.
636 <li class=
"listitem">
637 <span class=
"bold"><strong>Exception safety:
</strong></span> nothrow.
640 <a name=
"reference_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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
642 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
643 <li class=
"listitem">
644 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">position
</span></code>
645 is a valid dereferenceable iterator of the set view.
647 <li class=
"listitem">
648 <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
649 <code class=
"computeroutput"><span class=
"identifier">position
</span></code> into the
650 <code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> to which the
651 set view belongs if, for the value
<code class=
"computeroutput"><span class=
"identifier">x
</span></code>
652 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: circle; ">
653 <li class=
"listitem">
654 the set view is non-unique OR no other element with equivalent
655 key exists (except possibly
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"identifier">position
</span></code>),
657 <li class=
"listitem">
658 AND replacing is allowed by all other views of the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
662 <li class=
"listitem">
663 <span class=
"bold"><strong>Postconditions:
</strong></span> Validity of position
664 is preserved in all cases.
666 <li class=
"listitem">
667 <span class=
"bold"><strong>Returns:
</strong></span> <code class=
"computeroutput"><span class=
"keyword">true
</span></code>
668 if the replacement took place,
<code class=
"computeroutput"><span class=
"keyword">false
</span></code>
671 <li class=
"listitem">
672 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
675 <li class=
"listitem">
676 <span class=
"bold"><strong>Exception safety:
</strong></span> Strong. If an
677 exception is thrown by some user-provided operation, the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> to which the set view belongs
678 remains in its original state.
681 <a name=
"reference_set_of_replace_key_iterator_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
682 <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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
684 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
685 <li class=
"listitem">
686 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">position
</span></code>
687 is a valid dereferenceable iterator of the set view.
<code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code> can be assigned to
688 <code class=
"computeroutput"><span class=
"identifier">key_type
</span></code>.
690 <li class=
"listitem">
691 <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>,
692 where
<code class=
"computeroutput"><span class=
"identifier">e
</span></code> is the element
693 pointed to by
<code class=
"computeroutput"><span class=
"identifier">position
</span></code>
694 into the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> to
695 which the set view belongs if,
696 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: circle; ">
697 <li class=
"listitem">
698 the map view is non-unique OR no other element with equivalent
699 key exists (except possibly
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"identifier">position
</span></code>),
701 <li class=
"listitem">
702 AND replacing is allowed by all other views of the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
706 <li class=
"listitem">
707 <span class=
"bold"><strong>Postconditions:
</strong></span> Validity of position
708 is preserved in all cases.
710 <li class=
"listitem">
711 <span class=
"bold"><strong>Returns:
</strong></span> <code class=
"computeroutput"><span class=
"keyword">true
</span></code>
712 if the replacement took place,
<code class=
"computeroutput"><span class=
"keyword">false
</span></code>
715 <li class=
"listitem">
716 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
719 <li class=
"listitem">
720 <span class=
"bold"><strong>Exception safety:
</strong></span> Strong. If an
721 exception is thrown by some user-provided operation, the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> to which the set view belongs
722 remains in its original state.
725 <a name=
"reference_set_of_replace_data_iterator_data"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleData
</span> <span class=
"special">></span>
726 <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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
728 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
729 <li class=
"listitem">
730 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">position
</span></code>
731 is a valid dereferenceable iterator of the set view.
<code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code> can be assigned to
732 <code class=
"computeroutput"><span class=
"identifier">mapped_type
</span></code>.
734 <li class=
"listitem">
735 <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>,
736 where
<code class=
"computeroutput"><span class=
"identifier">e
</span></code> is the element
737 pointed to by
<code class=
"computeroutput"><span class=
"identifier">position
</span></code>
738 into the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> to
739 which the set view belongs if,
740 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: circle; ">
741 <li class=
"listitem">
742 the map view is non-unique OR no other element with equivalent
743 key exists (except possibly
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"identifier">position
</span></code>),
745 <li class=
"listitem">
746 AND replacing is allowed by all other views of the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
750 <li class=
"listitem">
751 <span class=
"bold"><strong>Postconditions:
</strong></span> Validity of position
752 is preserved in all cases.
754 <li class=
"listitem">
755 <span class=
"bold"><strong>Returns:
</strong></span> <code class=
"computeroutput"><span class=
"keyword">true
</span></code>
756 if the replacement took place,
<code class=
"computeroutput"><span class=
"keyword">false
</span></code>
759 <li class=
"listitem">
760 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
763 <li class=
"listitem">
764 <span class=
"bold"><strong>Exception safety:
</strong></span> Strong. If an
765 exception is thrown by some user-provided operation, the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> to which the set view belongs
766 remains in its original state.
769 <a name=
"reference_set_of_modify_key_iterator_modifier"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">KeyModifier
</span> <span class=
"special">></span>
770 <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>
772 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
773 <li class=
"listitem">
774 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">KeyModifier
</span></code>
775 is a model of
<a href=
"http://www.sgi.com/tech/stl/UnaryFunction.html" target=
"_top">Unary
776 Function
</a> accepting arguments of type:
<code class=
"computeroutput"><span class=
"identifier">key_type
</span><span class=
"special">&</span></code>;
<code class=
"computeroutput"><span class=
"identifier">position
</span></code>
777 is a valid dereferenceable iterator of the view.
779 <li class=
"listitem">
780 <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
781 by position and rearranges
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"identifier">position
</span></code> into all the views of
782 the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>. If the
783 rearrangement fails, the element is erased. Rearrangement is successful
785 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: circle; ">
786 <li class=
"listitem">
787 the map view is non-unique OR no other element with equivalent
790 <li class=
"listitem">
791 AND rearrangement is allowed by all other views of the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
795 <li class=
"listitem">
796 <span class=
"bold"><strong>Postconditions:
</strong></span> Validity of
<code class=
"computeroutput"><span class=
"identifier">position
</span></code> is preserved if the operation
799 <li class=
"listitem">
800 <span class=
"bold"><strong>Returns:
</strong></span> <code class=
"computeroutput"><span class=
"keyword">true
</span></code>
801 if the operation succeeded,
<code class=
"computeroutput"><span class=
"keyword">false
</span></code>
804 <li class=
"listitem">
805 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
808 <li class=
"listitem">
809 <span class=
"bold"><strong>Exception safety:
</strong></span> Basic. If an exception
810 is thrown by some user-provided operation (except possibly mod),
811 then the element pointed to by position is erased.
813 <li class=
"listitem">
814 <span class=
"bold"><strong>Note:
</strong></span> Only provided for map views.
817 <a name=
"reference_set_of_modify_data_iterator_modifier"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">DataModifier
</span> <span class=
"special">></span>
818 <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>
820 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
821 <li class=
"listitem">
822 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">DataModifier
</span></code>
823 is a model of
<a href=
"http://www.sgi.com/tech/stl/UnaryFunction.html" target=
"_top">Unary
824 Function
</a> accepting arguments of type:
<code class=
"computeroutput"><span class=
"identifier">mapped_type
</span><span class=
"special">&</span></code>;
<code class=
"computeroutput"><span class=
"identifier">position
</span></code>
825 is a valid dereferenceable iterator of the view.
827 <li class=
"listitem">
828 <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
829 by position and rearranges
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"identifier">position
</span></code> into all the views of
830 the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>. If the
831 rearrangement fails, the element is erased. Rearrangement is successful
833 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: circle; ">
834 <li class=
"listitem">
835 the oppositte map view is non-unique OR no other element with
836 equivalent key in that view exists,
838 <li class=
"listitem">
839 AND rearrangement is allowed by all other views of the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>.
843 <li class=
"listitem">
844 <span class=
"bold"><strong>Postconditions:
</strong></span> Validity of
<code class=
"computeroutput"><span class=
"identifier">position
</span></code> is preserved if the operation
847 <li class=
"listitem">
848 <span class=
"bold"><strong>Returns:
</strong></span> <code class=
"computeroutput"><span class=
"keyword">true
</span></code>
849 if the operation succeeded,
<code class=
"computeroutput"><span class=
"keyword">false
</span></code>
852 <li class=
"listitem">
853 <a class=
"link" href=
"set_of_reference.html#set_of_complexity_signature"><span class=
"bold"><strong>Complexity:
</strong></span></a>
856 <li class=
"listitem">
857 <span class=
"bold"><strong>Exception safety:
</strong></span> Basic. If an exception
858 is thrown by some user-provided operation (except possibly mod),
859 then the element pointed to by position is erased.
861 <li class=
"listitem">
862 <span class=
"bold"><strong>Note:
</strong></span> Only provided for map views.
866 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_set_operations">
867 <div class=
"titlepage"><div><div><h5 class=
"title">
868 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.set_operations"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.set_operations" title=
"Set operations">Set
870 </h5></div></div></div>
872 <code class=
"computeroutput"><span class=
"special">[
</span><span class=
"identifier">multi
</span><span class=
"special">]
</span><span class=
"identifier">set_of
</span></code>
873 views provide the full lookup functionality required by
<a href=
"http://www.sgi.com/tech/stl/SortedAssociativeContainer.html" target=
"_top">Sorted
874 Associative Container
</a> and
<a href=
"http://www.sgi.com/tech/stl/UniqueAssociativeContainer.html" target=
"_top">Unique
875 Associative Container
</a>, namely
<code class=
"computeroutput"><span class=
"identifier">find
</span></code>,
876 <code class=
"computeroutput"><span class=
"identifier">count
</span></code>,
<code class=
"computeroutput"><span class=
"identifier">lower_bound
</span></code>,
<code class=
"computeroutput"><span class=
"identifier">upper_bound
</span></code>
877 and
<code class=
"computeroutput"><span class=
"identifier">equal_range
</span></code>. Additionally,
878 these member functions are templatized to allow for non-standard arguments,
879 so extending the types of search operations allowed.
882 A type
<code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
883 is said to be a
<span class=
"emphasis"><em>compatible key
</em></span> of
<code class=
"computeroutput"><span class=
"identifier">Compare
</span></code> if
<code class=
"computeroutput"><span class=
"special">(
</span><span class=
"identifier">CompatibleKey
</span><span class=
"special">,
</span>
884 <span class=
"identifier">Compare
</span><span class=
"special">)
</span></code>
885 is a compatible extension of
<code class=
"computeroutput"><span class=
"identifier">Compare
</span></code>.
886 This implies that
<code class=
"computeroutput"><span class=
"identifier">Compare
</span></code>,
887 as well as being a strict weak ordering, accepts arguments of type
<code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>, which usually means
888 it has several overloads of
<code class=
"computeroutput"><span class=
"keyword">operator
</span><span class=
"special">()
</span></code>.
890 <a name=
"reference_set_of_find_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
891 <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">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
893 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
894 <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">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
896 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
897 <li class=
"listitem">
898 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
899 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
901 <li class=
"listitem">
902 <span class=
"bold"><strong>Effects:
</strong></span> Returns a pointer to an
903 element whose key is equivalent to
<code class=
"computeroutput"><span class=
"identifier">x
</span></code>,
904 or
<code class=
"computeroutput"><span class=
"identifier">end
</span><span class=
"special">()
</span></code>
905 if such an element does not exist.
907 <li class=
"listitem">
908 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
911 <a name=
"reference_set_of_count_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
912 <span class=
"identifier">size_type
</span> <span class=
"identifier">count
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">key_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
914 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
915 <li class=
"listitem">
916 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
917 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
919 <li class=
"listitem">
920 <span class=
"bold"><strong>Effects:
</strong></span> Returns the number of elements
921 with key equivalent to
<code class=
"computeroutput"><span class=
"identifier">x
</span></code>.
923 <li class=
"listitem">
924 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n) + count(x)).
927 <a name=
"reference_set_of_lower_bound_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
928 <span class=
"identifier">iterator
</span> <span class=
"identifier">lower_bound
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">key_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
930 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
931 <span class=
"identifier">const_iterator
</span> <span class=
"identifier">lower_bound
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">key_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
933 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
934 <li class=
"listitem">
935 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
936 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
938 <li class=
"listitem">
939 <span class=
"bold"><strong>Effects:
</strong></span> Returns an iterator pointing
940 to the first element with key not less than
<code class=
"computeroutput"><span class=
"identifier">x
</span></code>,
941 or
<code class=
"computeroutput"><span class=
"identifier">end
</span><span class=
"special">()
</span></code>
942 if such an element does not exist.
944 <li class=
"listitem">
945 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
948 <a name=
"reference_set_of_upper_bound_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
949 <span class=
"identifier">iterator
</span> <span class=
"identifier">upper_bound
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">key_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
951 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
952 <span class=
"identifier">const_iterator
</span> <span class=
"identifier">upper_bound
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">key_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
954 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
955 <li class=
"listitem">
956 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
957 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
959 <li class=
"listitem">
960 <span class=
"bold"><strong>Effects:
</strong></span> Returns an iterator pointing
961 to the first element with key greater than
<code class=
"computeroutput"><span class=
"identifier">x
</span></code>,
962 or
<code class=
"computeroutput"><span class=
"identifier">end
</span><span class=
"special">()
</span></code>
963 if such an element does not exist.
965 <li class=
"listitem">
966 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
969 <a name=
"reference_set_of_equal_range_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
970 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">iterator
</span><span class=
"special">,
</span><span class=
"identifier">iterator
</span><span class=
"special">></span>
971 <span class=
"identifier">equal_range
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">key_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">);
</span>
973 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
974 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">const_iterator
</span><span class=
"special">,
</span><span class=
"identifier">const_iterator
</span><span class=
"special">></span>
975 <span class=
"identifier">equal_range
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">key_type
</span> <span class=
"special">&</span> <span class=
"identifier">x
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
977 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
978 <li class=
"listitem">
979 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
980 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
982 <li class=
"listitem">
983 <span class=
"bold"><strong>Effects:
</strong></span> Equivalent to
<code class=
"computeroutput"><span class=
"identifier">make_pair
</span><span class=
"special">(
</span><span class=
"identifier">lower_bound
</span><span class=
"special">(
</span><span class=
"identifier">x
</span><span class=
"special">),
</span><span class=
"identifier">upper_bound
</span><span class=
"special">(
</span><span class=
"identifier">x
</span><span class=
"special">))
</span></code>.
985 <li class=
"listitem">
986 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
990 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_range_operations">
991 <div class=
"titlepage"><div><div><h5 class=
"title">
992 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.range_operations"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.range_operations" title=
"Range operations">Range
994 </h5></div></div></div>
996 The member function range is not defined for sorted associative containers,
997 but
<code class=
"computeroutput"><span class=
"special">[
</span><span class=
"identifier">multi
</span><span class=
"special">]
</span><span class=
"identifier">set_of
</span></code>
998 map views provide it as a convenient utility. A range or interval is
999 defined by two conditions for the lower and upper bounds, which are modelled
1000 after the following concepts.
1003 Consider a
<a href=
"http://www.sgi.com/tech/stl/StrictWeakOrdering.html" target=
"_top">Strict
1004 Weak Ordering
</a> <code class=
"computeroutput"><span class=
"identifier">Compare
</span></code>
1005 over values of type Key. A type
<code class=
"computeroutput"><span class=
"identifier">LowerBounder
</span></code>
1006 is said to be a lower bounder of
<code class=
"computeroutput"><span class=
"identifier">Compare
</span></code>
1009 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1010 <li class=
"listitem">
1011 <code class=
"computeroutput"><span class=
"identifier">LowerBounder
</span></code> is a
1012 <code class=
"computeroutput"><span class=
"identifier">Predicate
</span></code> over
<code class=
"computeroutput"><span class=
"identifier">Key
</span></code>,
1014 <li class=
"listitem">
1015 if
<code class=
"computeroutput"><span class=
"identifier">lower
</span><span class=
"special">(
</span><span class=
"identifier">k1
</span><span class=
"special">)
</span></code>
1016 and
<code class=
"computeroutput"><span class=
"special">!
</span><span class=
"identifier">comp
</span><span class=
"special">(
</span><span class=
"identifier">k2
</span><span class=
"special">,
</span><span class=
"identifier">k1
</span><span class=
"special">)
</span></code> then
<code class=
"computeroutput"><span class=
"identifier">lower
</span><span class=
"special">(
</span><span class=
"identifier">k2
</span><span class=
"special">)
</span></code>,
1020 for every
<code class=
"computeroutput"><span class=
"identifier">lower
</span></code> of type
1021 <code class=
"computeroutput"><span class=
"identifier">LowerBounder
</span></code>,
<code class=
"computeroutput"><span class=
"identifier">comp
</span></code> of type
<code class=
"computeroutput"><span class=
"identifier">Compare
</span></code>,
1022 and
<code class=
"computeroutput"><span class=
"identifier">k1
</span></code>,
<code class=
"computeroutput"><span class=
"identifier">k2
</span></code> of type
<code class=
"computeroutput"><span class=
"identifier">Key
</span></code>.
1023 Similarly, an upper bounder is a type
<code class=
"computeroutput"><span class=
"identifier">UpperBounder
</span></code>
1026 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1027 <li class=
"listitem">
1028 <code class=
"computeroutput"><span class=
"identifier">UpperBounder
</span></code> is a
1029 <code class=
"computeroutput"><span class=
"identifier">Predicate
</span></code> over
<code class=
"computeroutput"><span class=
"identifier">Key
</span></code>,
1031 <li class=
"listitem">
1032 if
<code class=
"computeroutput"><span class=
"identifier">upper
</span><span class=
"special">(
</span><span class=
"identifier">k1
</span><span class=
"special">)
</span></code>
1033 and
<code class=
"computeroutput"><span class=
"special">!
</span><span class=
"identifier">comp
</span><span class=
"special">(
</span><span class=
"identifier">k1
</span><span class=
"special">,
</span><span class=
"identifier">k2
</span><span class=
"special">)
</span></code> then
<code class=
"computeroutput"><span class=
"identifier">upper
</span><span class=
"special">(
</span><span class=
"identifier">k2
</span><span class=
"special">)
</span></code>,
1037 for every
<code class=
"computeroutput"><span class=
"identifier">upper
</span></code> of type
1038 <code class=
"computeroutput"><span class=
"identifier">UpperBounder
</span></code>,
<code class=
"computeroutput"><span class=
"identifier">comp
</span></code> of type
<code class=
"computeroutput"><span class=
"identifier">Compare
</span></code>,
1039 and
<code class=
"computeroutput"><span class=
"identifier">k1
</span></code>,
<code class=
"computeroutput"><span class=
"identifier">k2
</span></code> of type
<code class=
"computeroutput"><span class=
"identifier">Key
</span></code>.
1041 <a name=
"reference_set_of_range_lower_upper"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">LowerBounder
</span><span class=
"special">,
</span> <span class=
"keyword">class
</span> <span class=
"identifier">UpperBounder
</span><span class=
"special">></span>
1042 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">pair
</span><span class=
"special"><</span><span class=
"identifier">const_iterator
</span><span class=
"special">,
</span><span class=
"identifier">const_iterator
</span><span class=
"special">></span> <span class=
"identifier">range
</span><span class=
"special">(
</span>
1043 <span class=
"identifier">LowerBounder
</span> <span class=
"identifier">lower
</span><span class=
"special">,
</span> <span class=
"identifier">UpperBounder
</span> <span class=
"identifier">upper
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
1045 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1046 <li class=
"listitem">
1047 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">LowerBounder
</span></code>
1048 and
<code class=
"computeroutput"><span class=
"identifier">UpperBounder
</span></code>
1049 are a lower and upper bounder of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>,
1052 <li class=
"listitem">
1053 <span class=
"bold"><strong>Effects:
</strong></span> Returns a pair of iterators
1054 pointing to the beginning and one past the end of the subsequence
1055 of elements satisfying lower and upper simultaneously. If no such
1056 elements exist, the iterators both point to the first element satisfying
1057 lower, or else are equal to
<code class=
"computeroutput"><span class=
"identifier">end
</span><span class=
"special">()
</span></code> if this latter element does not
1060 <li class=
"listitem">
1061 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
1063 <li class=
"listitem">
1064 <span class=
"bold"><strong>Variants:
</strong></span> In place of lower or upper
1065 (or both), the singular value
<code class=
"computeroutput"><span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">bimap
</span><span class=
"special">::
</span><span class=
"identifier">unbounded
</span></code>
1066 can be provided. This acts as a predicate which all values of type
1067 <code class=
"computeroutput"><span class=
"identifier">key_type
</span></code> satisfy.
1069 <li class=
"listitem">
1070 <span class=
"bold"><strong>Note:
</strong></span> Only provided for map views.
1074 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_at____info_at___and_operator_______set_of_only">
1075 <div class=
"titlepage"><div><div><h5 class=
"title">
1076 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.at____info_at___and_operator_______set_of_only"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.at____info_at___and_operator_______set_of_only" title=
"at(), info_at() and operator[] - set_of only">at(),
1077 info_at() and operator[] - set_of only
</a>
1078 </h5></div></div></div>
1079 <a name=
"reference_set_of_at_key_const"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
1080 <span class=
"keyword">const
</span> <span class=
"identifier">mapped_type
</span> <span class=
"special">&</span> <span class=
"identifier">at
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
1082 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1083 <li class=
"listitem">
1084 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
1085 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
1087 <li class=
"listitem">
1088 <span class=
"bold"><strong>Effects:
</strong></span> Returns the
<code class=
"computeroutput"><span class=
"identifier">mapped_type
</span></code> reference that is associated
1089 with
<code class=
"computeroutput"><span class=
"identifier">k
</span></code>, or throws
1090 <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
1093 <li class=
"listitem">
1094 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
1096 <li class=
"listitem">
1097 <span class=
"bold"><strong>Note:
</strong></span> Only provided when
<code class=
"computeroutput"><span class=
"identifier">set_of
</span></code> is used.
1101 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()
1102 that are not found in
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">maps
</span></code>.
1103 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>
1104 and
<code class=
"computeroutput"><span class=
"identifier">unconstrained_set_of
</span></code>).
1106 <a name=
"reference_set_of_operator_bracket_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
1107 <span class=
"identifier">mapped_type
</span> <span class=
"special">&</span> <span class=
"keyword">operator
</span><span class=
"special">[](
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">);
</span>
1109 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1110 <li class=
"listitem">
1111 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
1112 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
1114 <li class=
"listitem">
1115 <span class=
"bold"><strong>Effects:
</strong></span> <code class=
"computeroutput"><span class=
"keyword">return
</span>
1116 <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">()))-
></span><span class=
"identifier">second
</span><span class=
"special">;
</span></code>
1118 <li class=
"listitem">
1119 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
1121 <li class=
"listitem">
1122 <span class=
"bold"><strong>Note:
</strong></span> Only provided when
<code class=
"computeroutput"><span class=
"identifier">set_of
</span></code> is used and the other collection
1126 <a name=
"reference_set_of_at_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
1127 <span class=
"identifier">mapped_type
</span> <span class=
"special">&</span> <span class=
"identifier">at
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">);
</span>
1129 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1130 <li class=
"listitem">
1131 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
1132 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
1134 <li class=
"listitem">
1135 <span class=
"bold"><strong>Effects:
</strong></span> Returns the
<code class=
"computeroutput"><span class=
"identifier">mapped_type
</span></code> reference that is associated
1136 with
<code class=
"computeroutput"><span class=
"identifier">k
</span></code>, or throws
1137 <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
1140 <li class=
"listitem">
1141 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
1143 <li class=
"listitem">
1144 <span class=
"bold"><strong>Note:
</strong></span> Only provided when
<code class=
"computeroutput"><span class=
"identifier">set_of
</span></code> is used and the other collection
1148 <a name=
"reference_set_of_info_at_key"></a><pre class=
"programlisting"><span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
1149 <span class=
"identifier">info_type
</span> <span class=
"special">&</span> <span class=
"identifier">info_at
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">);
</span>
1151 <span class=
"keyword">template
</span><span class=
"special"><</span> <span class=
"keyword">class
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">></span>
1152 <span class=
"keyword">const
</span> <span class=
"identifier">info_type
</span> <span class=
"special">&</span> <span class=
"identifier">info_at
</span><span class=
"special">(
</span><span class=
"keyword">const
</span> <span class=
"identifier">CompatibleKey
</span> <span class=
"special">&</span> <span class=
"identifier">k
</span><span class=
"special">)
</span> <span class=
"keyword">const
</span><span class=
"special">;
</span>
1154 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1155 <li class=
"listitem">
1156 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">CompatibleKey
</span></code>
1157 is a compatible key of
<code class=
"computeroutput"><span class=
"identifier">key_compare
</span></code>.
1159 <li class=
"listitem">
1160 <span class=
"bold"><strong>Effects:
</strong></span> Returns the
<code class=
"computeroutput"><span class=
"identifier">info_type
</span></code> reference that is associated
1161 with
<code class=
"computeroutput"><span class=
"identifier">k
</span></code>, or throws
1162 <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
1165 <li class=
"listitem">
1166 <span class=
"bold"><strong>Complexity:
</strong></span> O(log(n)).
1168 <li class=
"listitem">
1169 <span class=
"bold"><strong>Note:
</strong></span> Only provided when
<code class=
"computeroutput"><span class=
"identifier">set_of
</span></code> and
<code class=
"computeroutput"><span class=
"identifier">info_hook
</span></code>
1174 <div class=
"section boost_bimap_reference_set_of_reference___multi__set_of_views_serialization">
1175 <div class=
"titlepage"><div><div><h5 class=
"title">
1176 <a name=
"boost_bimap.reference.set_of_reference.__multi__set_of_views.serialization"></a><a class=
"link" href=
"set_of_reference.html#boost_bimap.reference.set_of_reference.__multi__set_of_views.serialization" title=
"Serialization">Serialization
</a>
1177 </h5></div></div></div>
1179 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.
1180 In describing the additional preconditions and guarantees associated
1181 to
<code class=
"computeroutput"><span class=
"special">[
</span><span class=
"identifier">multi
</span><span class=
"special">]
</span><span class=
"identifier">set_of
</span></code>
1182 views with respect to serialization of their embedding containers, we
1183 use the concepts defined in the
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>
1184 serialization section.
1186 <div class=
"sidebar">
1187 <div class=
"titlepage"></div>
1189 <span class=
"bold"><strong>Operation:
</strong></span> saving of a
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> m to an output archive (XML archive)
1193 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; "><li class=
"listitem">
1194 <span class=
"bold"><strong>Requires:
</strong></span> No additional requirements
1195 to those imposed by the container.
1197 <div class=
"sidebar">
1198 <div class=
"titlepage"></div>
1200 <span class=
"bold"><strong>Operation:
</strong></span> loading of a
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code> m' from an input archive (XML
1204 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1205 <li class=
"listitem">
1206 <span class=
"bold"><strong>Requires:
</strong></span> In addition to the general
1207 requirements,
<code class=
"computeroutput"><span class=
"identifier">value_comp
</span><span class=
"special">()
</span></code> must be serialization-compatible
1208 with
<code class=
"computeroutput"><span class=
"identifier">m
</span><span class=
"special">.
</span><span class=
"identifier">get
</span><span class=
"special"><</span><span class=
"identifier">i
</span><span class=
"special">>().
</span><span class=
"identifier">value_comp
</span><span class=
"special">()
</span></code>,
1209 where i is the position of the ordered view in the container.
1211 <li class=
"listitem">
1212 <span class=
"bold"><strong>Postconditions:
</strong></span> On successful loading,
1213 each of the elements of
<code class=
"computeroutput"><span class=
"special">[
</span><span class=
"identifier">begin
</span><span class=
"special">(),
</span>
1214 <span class=
"identifier">end
</span><span class=
"special">())
</span></code>
1215 is a restored copy of the corresponding 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"><</span><span class=
"identifier">i
</span><span class=
"special">>().
</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"><</span><span class=
"identifier">i
</span><span class=
"special">>().
</span><span class=
"identifier">end
</span><span class=
"special">())
</span></code>.
1218 <div class=
"sidebar">
1219 <div class=
"titlepage"></div>
1221 <span class=
"bold"><strong>Operation:
</strong></span> saving of an iterator or
1222 <code class=
"computeroutput"><span class=
"identifier">const_iterator
</span></code> it to
1223 an output archive (XML archive) ar.
1226 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; "><li class=
"listitem">
1227 <span class=
"bold"><strong>Requires:
</strong></span> <code class=
"computeroutput"><span class=
"identifier">it
</span></code>
1228 is a valid iterator of the view. The associated
<code class=
"computeroutput"><span class=
"identifier">bimap
</span></code>
1229 has been previously saved.
1231 <div class=
"sidebar">
1232 <div class=
"titlepage"></div>
1234 <span class=
"bold"><strong>Operation:
</strong></span> loading of an
<code class=
"computeroutput"><span class=
"identifier">iterator
</span></code> or
<code class=
"computeroutput"><span class=
"identifier">const_iterator
</span></code>
1235 <code class=
"computeroutput"><span class=
"identifier">it
</span></code>' from an input archive
1239 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
1240 <li class=
"listitem">
1241 <span class=
"bold"><strong>Postconditions:
</strong></span> On successful loading,
1242 if it was dereferenceable then
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"identifier">it
</span></code>' is the restored copy of
<code class=
"computeroutput"><span class=
"special">*
</span><span class=
"identifier">it
</span></code>,
1243 otherwise
<code class=
"computeroutput"><span class=
"identifier">it
</span></code>'
<code class=
"computeroutput">
1244 <span class=
"special">==
</span> <span class=
"identifier">end
</span><span class=
"special">()
</span></code>.
1246 <li class=
"listitem">
1247 <span class=
"bold"><strong>Note:
</strong></span> It is allowed that it be a
1248 <code class=
"computeroutput"><span class=
"identifier">const_iterator
</span></code> and
1249 the restored
<code class=
"computeroutput"><span class=
"identifier">it
</span></code>'
1250 an iterator, or viceversa.
1256 <table xmlns:
rev=
"http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width=
"100%"><tr>
1257 <td align=
"left"></td>
1258 <td align=
"right"><div class=
"copyright-footer">Copyright
© 2006-
2012 Matias Capeletto
<p>
1259 Distributed under the Boost Software License, Version
1.0. (See accompanying
1260 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>)
1265 <div class=
"spirit-nav">
1266 <a accesskey=
"p" href=
"bimap_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=
"unordered_set_of_reference.html"><img src=
"../../../../../../doc/src/images/next.png" alt=
"Next"></a>