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 <iterator>
21#include <memory>
22
23namespace boost
24{
25namespace ptr_container
26{
27 template< class PtrContainer >
28 class ptr_back_insert_iterator;
29
30 template< class PtrContainer >
31 class ptr_front_insert_iterator;
32
33 template< class PtrContainer >
34 class ptr_insert_iterator;
35
36 template< class PtrContainer >
37 ptr_back_insert_iterator<PtrContainer>
38 ptr_back_inserter( PtrContainer& cont );
39
40 template< class PtrContainer >
41 ptr_front_insert_iterator<PtrContainer>
42 ptr_front_inserter( PtrContainer& cont );
43
44 template< class PtrContainer >
45 ptr_insert_iterator<PtrContainer>
46 ptr_inserter( PtrContainer& cont, typename PtrContainer::iterator before );
47
48 //////////////////////////////////////////////////////////////////////////
49 // Implementation
50 //////////////////////////////////////////////////////////////////////////
51
52
53 template< class PtrContainer >
54 class ptr_back_insert_iterator :
55 public std::iterator<std::output_iterator_tag,void,void,void,void>
56 {
57 public:
58 typedef PtrContainer container_type;
59
60 public:
61 explicit ptr_back_insert_iterator( PtrContainer& cont )
62 : container(&cont)
63 { }
64
65 ptr_back_insert_iterator&
66 operator=( typename PtrContainer::value_type r )
67 {
68 typename PtrContainer::value_type obj = 0;
69 if( r != 0 )
70 obj = container_type::clone_allocator_type::allocate_clone(*r);
71
72 container->push_back( obj );
73 return *this;
74 }
75
76 template< class T >
77 ptr_back_insert_iterator&
78 operator=( std::auto_ptr<T> r )
79 {
80 container->push_back( r );
81 return *this;
82 }
83
84 ptr_back_insert_iterator&
85 operator=( typename PtrContainer::const_reference r )
86 {
87 container->push_back( container_type::clone_allocator_type::
88 allocate_clone(r) );
89 return *this;
90 }
91
92 ptr_back_insert_iterator& operator*()
93 {
94 return *this;
95 }
96
97 ptr_back_insert_iterator& operator++()
98 {
99 return *this;
100 }
101
102 ptr_back_insert_iterator operator++(int)
103 {
104 return *this;
105 }
106
107 protected:
108 PtrContainer* container;
109 };
110
111
112
113 template< class PtrContainer >
114 class ptr_front_insert_iterator :
115 public std::iterator<std::output_iterator_tag,void,void,void,void>
116 {
117 public:
118 typedef PtrContainer container_type;
119
120 public:
121 explicit ptr_front_insert_iterator( PtrContainer& cont )
122 : container(&cont)
123 { }
124
125 ptr_front_insert_iterator&
126 operator=( typename PtrContainer::value_type r )
127 {
128 typename PtrContainer::value_type obj = 0;
129 if( r != 0 )
130 obj = container_type::clone_allocator_type::allocate_clone(*r);
131
132 container->push_front( obj );
133 return *this;
134 }
135
136 template< class T >
137 ptr_front_insert_iterator&
138 operator=( std::auto_ptr<T> r )
139 {
140 container->push_front( r );
141 return *this;
142 }
143
144 ptr_front_insert_iterator&
145 operator=( typename PtrContainer::const_reference r )
146 {
147 container->push_front( container_type::clone_allocator_type::
148 allocate_clone(r) );
149 return *this;
150 }
151
152 ptr_front_insert_iterator& operator*()
153 {
154 return *this;
155 }
156
157 ptr_front_insert_iterator& operator++()
158 {
159 return *this;
160 }
161
162 ptr_front_insert_iterator operator++(int)
163 {
164 return *this;
165 }
166
167 protected:
168 PtrContainer* container;
169 };
170
171
172
173 template< class PtrContainer >
174 class ptr_insert_iterator :
175 public std::iterator<std::output_iterator_tag,void,void,void,void>
176 {
177 public:
178 typedef PtrContainer container_type;
179
180 public:
181 ptr_insert_iterator( PtrContainer& cont,
182 typename PtrContainer::iterator before )
183 : container(&cont), iter(before)
184 { }
185
186 ptr_insert_iterator&
187 operator=( typename PtrContainer::value_type r )
188 {
189 typename PtrContainer::value_type obj = 0;
190 if( r != 0 )
191 obj = container_type::clone_allocator_type::allocate_clone(*r);
192
193 iter = container->insert( iter, obj );
194 return *this;
195 }
196
197 template< class T >
198 ptr_insert_iterator&
199 operator=( std::auto_ptr<T> r )
200 {
201 iter = container->insert( iter, r );
202 return *this;
203 }
204
205 ptr_insert_iterator&
206 operator=( typename PtrContainer::const_reference r )
207 {
208 iter = container->insert( iter, container_type::clone_allocator_type::
209 allocate_clone(r) );
210 return *this;
211 }
212
213 ptr_insert_iterator& operator*()
214 {
215 return *this;
216 }
217
218 ptr_insert_iterator& operator++()
219 {
220 return *this;
221 }
222
223 ptr_insert_iterator operator++(int)
224 {
225 return *this;
226 }
227
228 protected:
229 PtrContainer* container;
230 typename PtrContainer::iterator iter;
231 };
232
233 template< class PtrContainer >
234 inline ptr_back_insert_iterator<PtrContainer>
235 ptr_back_inserter( PtrContainer& cont )
236 {
237 return ptr_back_insert_iterator<PtrContainer>( cont );
238 }
239
240 template< class PtrContainer >
241 inline ptr_front_insert_iterator<PtrContainer>
242 ptr_front_inserter( PtrContainer& cont )
243 {
244 return ptr_front_insert_iterator<PtrContainer>( cont );
245 }
246
247 template< class PtrContainer >
248 inline ptr_insert_iterator<PtrContainer>
249 ptr_inserter( PtrContainer& cont,
250 typename PtrContainer::iterator before )
251 {
252 return ptr_insert_iterator<PtrContainer>( cont, before );
253 }
254
255} // namespace 'ptr_container'
256} // namespace 'boost'
257
258#endif
259

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