]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
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 |