1//
2// Boost.Pointer Container
3//
4// Copyright Thorsten Ottosen 2008. Use, modification and
5// distribution is subject to the Boost Software License, Version
6// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
7// http://www.boost.org/LICENSE_1_0.txt)
8//
9// For more information, see http://www.boost.org/libs/ptr_container/
10//
11
12#ifndef BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
13#define BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
14
15#if defined(_MSC_VER) && (_MSC_VER >= 1200)
16 #pragma once
17#endif
18
19#include <boost/config.hpp>
20#include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
21#include <iterator>
22#include <memory>
23
24#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
25#pragma GCC diagnostic push
26#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
27#endif
28
29namespace boost
30{
31namespace ptr_container
32{
33 template< class PtrContainer >
34 class ptr_back_insert_iterator;
35
36 template< class PtrContainer >
37 class ptr_front_insert_iterator;
38
39 template< class PtrContainer >
40 class ptr_insert_iterator;
41
42 template< class PtrContainer >
43 ptr_back_insert_iterator<PtrContainer>
44 ptr_back_inserter( PtrContainer& cont );
45
46 template< class PtrContainer >
47 ptr_front_insert_iterator<PtrContainer>
48 ptr_front_inserter( PtrContainer& cont );
49
50 template< class PtrContainer >
51 ptr_insert_iterator<PtrContainer>
52 ptr_inserter( PtrContainer& cont, typename PtrContainer::iterator before );
53
54 //////////////////////////////////////////////////////////////////////////
55 // Implementation
56 //////////////////////////////////////////////////////////////////////////
57
58
59 template< class PtrContainer >
60 class ptr_back_insert_iterator
61 {
62 public:
63 typedef std::output_iterator_tag iterator_category;
64 typedef void value_type;
65 typedef void difference_type;
66 typedef void pointer;
67 typedef void reference;
68 typedef PtrContainer container_type;
69
70 public:
71 explicit ptr_back_insert_iterator( PtrContainer& cont )
72 : container(&cont)
73 { }
74
75 ptr_back_insert_iterator&
76 operator=( typename PtrContainer::value_type r )
77 {
78 typename PtrContainer::value_type obj
79 = container->null_policy_allocate_clone(r);
80 container->push_back( obj );
81 return *this;
82 }
83
84#ifndef BOOST_NO_AUTO_PTR
85 template< class T >
86 ptr_back_insert_iterator&
87 operator=( std::auto_ptr<T> r )
88 {
89 container->push_back( r );
90 return *this;
91 }
92#endif
93#ifndef BOOST_NO_CXX11_SMART_PTR
94 template< class T >
95 ptr_back_insert_iterator&
96 operator=( std::unique_ptr<T> r )
97 {
98 container->push_back( std::move( r ) );
99 return *this;
100 }
101#endif
102
103 ptr_back_insert_iterator&
104 operator=( typename PtrContainer::const_reference r )
105 {
106 container->push_back( container->null_policy_allocate_clone(&r) );
107 return *this;
108 }
109
110 ptr_back_insert_iterator& operator*()
111 {
112 return *this;
113 }
114
115 ptr_back_insert_iterator& operator++()
116 {
117 return *this;
118 }
119
120 ptr_back_insert_iterator operator++(int)
121 {
122 return *this;
123 }
124
125 protected:
126 PtrContainer* container;
127 };
128
129
130
131 template< class PtrContainer >
132 class ptr_front_insert_iterator
133 {
134 public:
135 typedef std::output_iterator_tag iterator_category;
136 typedef void value_type;
137 typedef void difference_type;
138 typedef void pointer;
139 typedef void reference;
140 typedef PtrContainer container_type;
141
142 public:
143 explicit ptr_front_insert_iterator( PtrContainer& cont )
144 : container(&cont)
145 { }
146
147 ptr_front_insert_iterator&
148 operator=( typename PtrContainer::value_type r )
149 {
150 typename PtrContainer::value_type obj
151 = container->null_policy_allocate_clone(r);
152 container->push_front( obj );
153 return *this;
154 }
155
156#ifndef BOOST_NO_AUTO_PTR
157 template< class T >
158 ptr_front_insert_iterator&
159 operator=( std::auto_ptr<T> r )
160 {
161 container->push_front( r );
162 return *this;
163 }
164#endif
165#ifndef BOOST_NO_CXX11_SMART_PTR
166 template< class T >
167 ptr_front_insert_iterator&
168 operator=( std::unique_ptr<T> r )
169 {
170 container->push_front( std::move( r ) );
171 return *this;
172 }
173#endif
174
175 ptr_front_insert_iterator&
176 operator=( typename PtrContainer::const_reference r )
177 {
178 container->push_front( container->null_policy_allocate_clone(&r) );
179 return *this;
180 }
181
182 ptr_front_insert_iterator& operator*()
183 {
184 return *this;
185 }
186
187 ptr_front_insert_iterator& operator++()
188 {
189 return *this;
190 }
191
192 ptr_front_insert_iterator operator++(int)
193 {
194 return *this;
195 }
196
197 protected:
198 PtrContainer* container;
199 };
200
201
202
203 template< class PtrContainer >
204 class ptr_insert_iterator
205 {
206 public:
207 typedef std::output_iterator_tag iterator_category;
208 typedef void value_type;
209 typedef void difference_type;
210 typedef void pointer;
211 typedef void reference;
212 typedef PtrContainer container_type;
213
214 public:
215 ptr_insert_iterator( PtrContainer& cont,
216 typename PtrContainer::iterator before )
217 : container(&cont), iter(before)
218 { }
219
220 ptr_insert_iterator&
221 operator=( typename PtrContainer::value_type r )
222 {
223 typename PtrContainer::value_type obj =
224 container->null_policy_allocate_clone(r);
225
226 iter = container->insert( iter, obj );
227 return *this;
228 }
229
230#ifndef BOOST_NO_AUTO_PTR
231 template< class T >
232 ptr_insert_iterator&
233 operator=( std::auto_ptr<T> r )
234 {
235 iter = container->insert( iter, r );
236 return *this;
237 }
238#endif
239#ifndef BOOST_NO_CXX11_SMART_PTR
240 template< class T >
241 ptr_insert_iterator&
242 operator=( std::unique_ptr<T> r )
243 {
244 iter = container->insert( iter, std::move( r ) );
245 return *this;
246 }
247#endif
248
249 ptr_insert_iterator&
250 operator=( typename PtrContainer::const_reference r )
251 {
252 iter = container->insert( iter,
253 container->null_policy_allocate_clone(&r) );
254 return *this;
255 }
256
257 ptr_insert_iterator& operator*()
258 {
259 return *this;
260 }
261
262 ptr_insert_iterator& operator++()
263 {
264 return *this;
265 }
266
267 ptr_insert_iterator operator++(int)
268 {
269 return *this;
270 }
271
272 protected:
273 PtrContainer* container;
274 typename PtrContainer::iterator iter;
275 };
276
277 template< class PtrContainer >
278 inline ptr_back_insert_iterator<PtrContainer>
279 ptr_back_inserter( PtrContainer& cont )
280 {
281 return ptr_back_insert_iterator<PtrContainer>( cont );
282 }
283
284 template< class PtrContainer >
285 inline ptr_front_insert_iterator<PtrContainer>
286 ptr_front_inserter( PtrContainer& cont )
287 {
288 return ptr_front_insert_iterator<PtrContainer>( cont );
289 }
290
291 template< class PtrContainer >
292 inline ptr_insert_iterator<PtrContainer>
293 ptr_inserter( PtrContainer& cont,
294 typename PtrContainer::iterator before )
295 {
296 return ptr_insert_iterator<PtrContainer>( cont, before );
297 }
298
299} // namespace 'ptr_container'
300} // namespace 'boost'
301
302#if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
303#pragma GCC diagnostic pop
304#endif
305
306#endif
307

source code of boost/libs/ptr_container/include/boost/ptr_container/ptr_inserter.hpp