1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
++++++++++++++++++++++++++++++++++
|Boost| Pointer Container Library
++++++++++++++++++++++++++++++++++
.. |Boost| image:: boost.png
Class ``ptr_map_adapter``
-------------------------
This class is used to build custom pointer containers with
an underlying map-like container. The interface of the class is an extension
of the interface from ``associative_ptr_container``.
**Hierarchy:**
- `reversible_ptr_container <reversible_ptr_container.html>`_
- `associative_ptr_container <associative_ptr_container.html>`_
- `ptr_set_adapter <ptr_set_adapter.html>`_
- `ptr_multiset_adapter <ptr_multiset_adapter.html>`_
- ``ptr_map_adapter``
- `ptr_multi_map_adapter <ptr_multimap_adapter.html>`_
- `ptr_set <ptr_set.html>`_
- `ptr_multi_set <ptr_multiset.html>`_
- `ptr_map <ptr_map.html>`_
- `ptr_multimap <ptr_multimap.html>`_
**Navigate:**
- `home <ptr_container.html>`_
- `reference <reference.html>`_
**Synopsis:**
.. parsed-literal::
namespace boost
{
template
<
class T,
class VoidPtrMap,
class CloneAllocator = heap_clone_allocator
>
class ptr_map_adapter
{
public: // `typedefs`_
typedef VoidPtrMap::key_type key_type;
typedef T* mapped_type;
typedef T& mapped_reference;
typedef const T& const_mapped_reference;
typedef ... value_type;
typedef ... reference;
typedef ... const_reference;
typedef ... pointer;
typedef ... const_pointer;
public: // `modifiers`_
std::pair<iterator,bool> insert( key_type& k, T* x );
template< class U >
std::pair<iterator,bool> insert( const key_type& k, std::auto_ptr<U> x );
public; // `lookup`_
T& operator[]( const key_type& key );
T& at( const key_type& key );
const T& at( const key_type& key ) const;
public: // `pointer container requirements`_
bool transfer( iterator object, ptr_map_adapter& from );
size_type transfer( iterator first, iterator last, ptr_map_adapter& from );
template< class Range >
size_type transfer( const Range& r, ptr_map_adapter& from );
size_type transfer( ptr_map_adapter& from );
}; // class 'ptr_map_adapter'
} // namespace 'boost'
Semantics
---------
.. _`typedefs`:
Semantics: typedefs
^^^^^^^^^^^^^^^^^^^
The following types are implementation defined::
typedef ... value_type;
typedef ... reference;
typedef ... const_reference;
typedef ... pointer;
typedef ... const_pointer;
However, the structure of the type mimics ``std::pair`` s.t. one
can use ``first`` and ``second`` members. The reference-types
are not real references and the pointer-types are not real pointers.
However, one may still write ::
map_type::value_type a_value = *m.begin();
a_value.second->foo();
map_type::reference a_reference = *m.begin();
a_reference.second->foo();
map_type::const_reference a_creference = *const_begin(m);
map_type::pointer a_pointer = &*m.begin();
a_pointer->second->foo();
map_type::const_pointer a_cpointer = &*const_begin(m);
The difference compared to ``std::map<Key,T*>`` is that constness
is propagated to the pointer (that is, to ``second``) in ``const_itertor``.
.. _`modifiers`:
Semantics: modifiers
^^^^^^^^^^^^^^^^^^^^
- ``std::pair<iterator,bool> insert( key_type& k, value_type x );``
- Requirements: ``x != 0``
- Effects: Takes ownership of ``x`` and insert it iff there is no equivalent of it already. The bool part of the return value indicates insertion and the iterator points to the element with key ``x``.
- Throws: bad_pointer if ``x == 0``
- Exception safety: Strong guarantee
- ``template< class U > std::pair<iterator,bool> insert( const key_type& k, std::auto_ptr<U> x );``
- Equivalent to (but without the ``const_cast``): ``return insert( const_cast<key_type&>(k), x.release() );``
..
- ``std::pair<iterator,bool> insert( key_type& k, const_reference x );``
- Effects: ``return insert( allocate_clone( x ) );``
- Exception safety: Strong guarantee
.. _`lookup`:
Semantics: lookup
^^^^^^^^^^^^^^^^^
- ``T& operator[]( const key_type& key );``
- Effects: returns the object with key ``key`` if it exists; otherwise a new object is allocated and inserted and its reference returned.
- Exception-safety: Strong guarantee
- ``T& at( const key_type& key );``
- ``const T& at( const key_type& jey ) const;``
- Requirement: the key exists
- Throws: ``bad_ptr_container_operation`` if the key does not exist
.. _`pointer container requirements`:
Semantics: pointer container requirements
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
- ``bool transfer( iterator object, ptr_map_adapter& from );``
- Requirements: ``not from.empty()``
- Effects: Inserts the object defined by ``object`` into the container and remove it from ``from``
iff no equivalent object exists.
- Returns: whether the object was transfered
- Exception safety: Strong guarantee
- ``size_type transfer( iterator first, iterator last, ptr__set_adapter& from );``
- Requirements: ``not from.empty()``
- Effects: Inserts the objects defined by the range ``[first,last)`` into the container and remove it from ``from``.
An object is only transferred if no equivalent object exists.
- Returns: the number of transfered objects
- Exception safety: Basic guarantee
- ``template< class Range > void transfer( const Range& r, ptr_map_adapter& from );``
- Effects: ``return transfer( boost::begin(r), boost::end(r), from );``
- ``size_type transfer( ptr_set_adapter& from );``
- Effects: ``return transfer( from.begin(), from.end(), from );``.
.. raw:: html
<hr>
:Copyright: Thorsten Ottosen 2004-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt__).
__ http://www.boost.org/LICENSE_1_0.txt
|
