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 | |
23 | namespace boost |
24 | { |
25 | namespace 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 | |