CppADCodeGen 2.4.3
A C++ Algorithmic Differentiation Package with Source Code Generation
Loading...
Searching...
No Matches
smart_containers.hpp
1#ifndef CPPAD_CG_SMART_CONTAINERS_INCLUDED
2#define CPPAD_CG_SMART_CONTAINERS_INCLUDED
3/* --------------------------------------------------------------------------
4 * CppADCodeGen: C++ Algorithmic Differentiation with Source Code Generation:
5 * Copyright (C) 2014 Ciengis
6 *
7 * CppADCodeGen is distributed under multiple licenses:
8 *
9 * - Eclipse Public License Version 1.0 (EPL1), and
10 * - GNU General Public License Version 3 (GPL3).
11 *
12 * EPL1 terms and conditions can be found in the file "epl-v10.txt", while
13 * terms and conditions for the GPL3 can be found in the file "gpl3.txt".
14 * ----------------------------------------------------------------------------
15 * Author: Joao Leal
16 */
17
18namespace CppAD {
19namespace cg {
20
25template<class Base>
27public:
28 using iterator = typename std::vector<Base*>::iterator;
29 using const_iterator = typename std::vector<Base*>::const_iterator;
30 using reverse_iterator = typename std::vector<Base*>::reverse_iterator;
31 using const_reverse_iterator = typename std::vector<Base*>::const_reverse_iterator;
32 std::vector<Base*> v;
33
34 inline SmartVectorPointer() {
35 }
36
37 inline SmartVectorPointer(size_t size) :
38 v(size) {
39 }
40
41 inline SmartVectorPointer(std::vector<Base*>& v_) {
42 v.swap(v_);
43 }
44
45 inline size_t size() const {
46 return v.size();
47 }
48
49 inline bool empty() const {
50 return v.empty();
51 }
52
53 inline void reserve(size_t n) {
54 v.reserve(n);
55 }
56
57 inline void push_back(Base* x) {
58 v.push_back(x);
59 }
60
61 inline Base* operator[](size_t n) const {
62 return v[n];
63 }
64
65 inline Base*& operator[](size_t n) {
66 return v[n];
67 }
68
69 inline iterator begin() {
70 return v.begin();
71 }
72
73 inline const_iterator begin() const {
74 return v.begin();
75 }
76
77 inline iterator end() {
78 return v.end();
79 }
80
81 inline const_iterator end() const {
82 return v.end();
83 }
84
85 inline reverse_iterator rbegin() {
86 return v.rbegin();
87 }
88
89 inline const_reverse_iterator rbegin() const {
90 return v.rbegin();
91 }
92
93 inline reverse_iterator rend() {
94 return v.rend();
95 }
96
97 inline const_reverse_iterator rend() const {
98 return v.rend();
99 }
100
101 inline std::vector<Base*> release() {
102 std::vector<Base*> v2;
103 v2.swap(v);
104 return v2;
105 }
106
107 inline virtual ~SmartVectorPointer() {
108 for (size_t i = 0; i < v.size(); i++) {
109 delete v[i];
110 }
111 }
112};
113
118template<class Base>
120public:
121 using iterator = typename std::set<Base*>::iterator;
122 std::set<Base*> s;
123
124 inline SmartSetPointer() {
125 }
126
127 inline SmartSetPointer(std::set<Base*>& s_) {
128 s.swap(s_);
129 }
130
131 inline size_t size() const {
132 return s.size();
133 }
134
135 inline bool empty() const {
136 return s.empty();
137 }
138
139 inline iterator begin() const {
140 return s.begin();
141 }
142
143 inline iterator end() const {
144 return s.end();
145 }
146
147 inline std::pair<iterator, bool> insert(Base* x) {
148 return s.insert(x);
149 }
150
151 inline void erase(iterator pos) {
152 s.erase(pos);
153 }
154
155 inline size_t erase(Base* x) {
156 return s.erase(x);
157 }
158
159 inline std::set<Base*> release() {
160 std::set<Base*> s2;
161 s2.swap(s);
162 return s2;
163 }
164
165 inline virtual ~SmartSetPointer() {
166 typename std::set<Base*>::const_iterator it;
167 for (it = s.begin(); it != s.end(); ++it) {
168 delete *it;
169 }
170 }
171};
172
177template<class Base>
179public:
180 using iterator = typename std::list<Base*>::iterator;
181 using const_iterator = typename std::list<Base*>::const_iterator;
182 std::list<Base*> l;
183
184 inline SmartListPointer() {
185 }
186
187 inline SmartListPointer(const std::set<Base*>& l_) {
188 l.swap(l_);
189 }
190
191 inline size_t size() const {
192 return l.size();
193 }
194
195 inline bool empty() const {
196 return l.empty();
197 }
198
199 inline void push_front(Base* x) {
200 l.push_front(x);
201 }
202
203 inline void pop_front() {
204 l.pop_front();
205 }
206
207 inline void push_back(Base* x) {
208 l.push_back(x);
209 }
210
211 inline void pop_back() {
212 l.pop_back();
213 }
214
215 inline iterator begin() {
216 return l.begin();
217 }
218
219 inline const_iterator begin() const {
220 return l.begin();
221 }
222
223 inline iterator end() {
224 return l.end();
225 }
226
227 inline const_iterator end() const {
228 return l.end();
229 }
230
231 inline std::list<Base*> release() {
232 std::list<Base*> l2;
233 l2.swap(l);
234 return l2;
235 }
236
237 inline virtual ~SmartListPointer() {
238 typename std::list<Base*>::const_iterator it;
239 for (it = l.begin(); it != l.end(); ++it) {
240 delete *it;
241 }
242 }
243};
244
245template<class Key, class Value>
247public:
248 using iterator = typename std::map<Key, Value*>::iterator;
249 using const_iterator = typename std::map<Key, Value*>::const_iterator;
250 using reverse_iterator = typename std::map<Key, Value*>::reverse_iterator;
251 using const_reverse_iterator = typename std::map<Key, Value*>::const_reverse_iterator;
252 std::map<Key, Value*> m;
253
254 inline size_t size() const {
255 return m.size();
256 }
257
258 inline bool empty() const {
259 return m.empty();
260 }
261
262 inline iterator begin() {
263 return m.begin();
264 }
265
266 inline const_iterator begin() const {
267 return m.begin();
268 }
269
270 inline iterator end() {
271 return m.end();
272 }
273
274 inline const_iterator end() const {
275 return m.end();
276 }
277
278 inline reverse_iterator rbegin() {
279 return m.rbegin();
280 }
281
282 inline const_reverse_iterator rbegin() const {
283 return m.rbegin();
284 }
285
286 inline reverse_iterator rend() {
287 return m.rend();
288 }
289
290 inline const_reverse_iterator rend() const {
291 return m.rend();
292 }
293
294 inline Value*& operator[](const Key& key) {
295 return m[key];
296 }
297
298 std::map<Key, Value*> release() {
299 std::map<Key, Value*> m2;
300 m2.swap(m);
301 return m2;
302 }
303
304 inline virtual ~SmartMapValuePointer() {
305 typename std::map<Key, Value*>::const_iterator it;
306 for (it = m.begin(); it != m.end(); ++it) {
307 delete it->second;
308 }
309 }
310};
311
312} // END cg namespace
313} // END CppAD namespace
314
315#endif