Mercurial > jwe > octave
annotate liboctave/util/action-container.h @ 21139:538b57866b90
consistently use "typename" intead of "class" in template declarations
* Object.h, QtHandlesUtils.cc, QtHandlesUtils.h, ToolBarButton.cc,
ToolBarButton.h, Cell.h, __lin_interpn__.cc, bitfcns.cc, bsxfun.cc,
cellfun.cc, data.cc, filter.cc, gcd.cc, graphics.cc, help.cc, kron.cc,
lookup.cc, ls-mat5.cc, ls-oct-text.h, lu.cc, max.cc, mgorth.cc,
oct-map.cc, oct-map.h, oct-stream.cc, oct-stream.h, octave-link.h,
pr-output.cc, profiler.h, schur.cc, sparse-xdiv.cc, sparse-xpow.cc,
sqrtm.cc, symtab.h, tril.cc, typecast.cc, variables.cc, xdiv.cc,
zfstream.h, __init_fltk__.cc, __magick_read__.cc, chol.cc, qr.cc,
ov-base-diag.cc, ov-base-diag.h, ov-base-int.cc, ov-base-int.h,
ov-base-mat.cc, ov-base-mat.h, ov-base-scalar.cc, ov-base-scalar.h,
ov-base-sparse.cc, ov-base-sparse.h, ov-base.h, ov-classdef.cc,
ov-int-traits.h, ov-java.h, ov-usr-fcn.h, ov.cc, ov.h,
op-dms-template.cc, oct-parse.in.yy, parse.h, pt-mat.cc, Array-b.cc,
Array.cc, Array.h, CDiagMatrix.h, CMatrix.h, CNDArray.h,
DiagArray2.cc, DiagArray2.h, MArray.cc, MArray.h, MDiagArray2.cc,
MDiagArray2.h, MSparse.cc, MSparse.h, MatrixType.cc, Sparse.cc,
Sparse.h, dDiagMatrix.h, dMatrix.h, dNDArray.h, fCDiagMatrix.h,
fCMatrix.h, fCNDArray.h, fDiagMatrix.h, fMatrix.h, fNDArray.h,
idx-vector.cc, idx-vector.h, intNDArray.cc, intNDArray.h, DET.h,
base-aepbal.h, base-lu.cc, base-lu.h, base-qr.cc, base-qr.h,
bsxfun-defs.cc, eigs-base.cc, lo-mappers.h, lo-specfun.cc,
lo-specfun.h, oct-convn.cc, oct-fftw.cc, oct-norm.cc,
sparse-base-chol.cc, sparse-base-chol.h, sparse-base-lu.cc,
sparse-base-lu.h, sparse-dmsolve.cc, mx-inlines.cc,
action-container.h, base-list.h, lo-traits.h, lo-utils.h,
oct-base64.h, oct-binmap.h, oct-cmplx.h, oct-inttypes.cc,
oct-inttypes.h, oct-locbuf.h, oct-refcount.h, oct-sort.cc, oct-sort.h:
Use "typename" instead of "class" in template declarations.
author | John W. Eaton <jwe@octave.org> |
---|---|
date | Sun, 24 Jan 2016 13:50:04 -0500 |
parents | f7084eae3318 |
children | 1473547f50f5 |
rev | line source |
---|---|
15396 | 1 /* |
2 | |
19697
4197fc428c7d
maint: Update copyright notices for 2015.
John W. Eaton <jwe@octave.org>
parents:
17769
diff
changeset
|
3 Copyright (C) 1993-2015 John W. Eaton |
15396 | 4 Copyright (C) 2009-2010 VZLU Prague |
5 | |
6 This file is part of Octave. | |
7 | |
8 Octave is free software; you can redistribute it and/or modify it | |
9 under the terms of the GNU General Public License as published by the | |
10 Free Software Foundation; either version 3 of the License, or (at your | |
11 option) any later version. | |
12 | |
13 Octave is distributed in the hope that it will be useful, but WITHOUT | |
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
19 along with Octave; see the file COPYING. If not, see | |
20 <http://www.gnu.org/licenses/>. | |
21 | |
22 */ | |
23 | |
20791
f7084eae3318
maint: Use Octave coding conventions for #if statements.
Rik <rik@octave.org>
parents:
19697
diff
changeset
|
24 #if ! defined (octave_action_container_h) |
15396 | 25 #define octave_action_container_h 1 |
26 | |
27 // This class allows registering actions in a list for later | |
28 // execution, either explicitly or when the container goes out of | |
29 // scope. | |
30 | |
17769
49a5a4be04a1
maint: Use GNU style coding conventions for code in liboctave/
Rik <rik@octave.org>
parents:
17744
diff
changeset
|
31 // FIXME: is there a better name for this class? |
15396 | 32 |
33 class | |
34 action_container | |
35 { | |
36 public: | |
37 | |
38 // A generic unwind_protect element. Knows how to run itself and | |
39 // discard itself. Also, contains a pointer to the next element. | |
40 class elem | |
41 { | |
42 public: | |
43 elem (void) { } | |
44 | |
45 virtual void run (void) { } | |
46 | |
47 virtual ~elem (void) { } | |
48 | |
49 friend class action_container; | |
50 | |
51 private: | |
52 | |
53 // No copying! | |
54 | |
55 elem (const elem&); | |
56 | |
57 elem& operator = (const elem&); | |
58 }; | |
59 | |
60 // An element that merely runs a void (*)(void) function. | |
61 | |
62 class fcn_elem : public elem | |
63 { | |
64 public: | |
65 fcn_elem (void (*fptr) (void)) | |
66 : e_fptr (fptr) { } | |
67 | |
68 void run (void) { e_fptr (); } | |
69 | |
70 private: | |
71 void (*e_fptr) (void); | |
72 }; | |
73 | |
74 // An element that stores a variable of type T along with a void (*) (T) | |
75 // function pointer, and calls the function with the parameter. | |
76 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
77 template <typename T> |
15396 | 78 class fcn_arg_elem : public elem |
79 { | |
80 public: | |
81 fcn_arg_elem (void (*fcn) (T), T arg) | |
82 : e_fcn (fcn), e_arg (arg) { } | |
83 | |
84 void run (void) { e_fcn (e_arg); } | |
85 | |
86 private: | |
87 | |
88 // No copying! | |
89 | |
90 fcn_arg_elem (const fcn_arg_elem&); | |
91 | |
92 fcn_arg_elem& operator = (const fcn_arg_elem&); | |
93 | |
94 void (*e_fcn) (T); | |
95 T e_arg; | |
96 }; | |
97 | |
98 // An element that stores a variable of type T along with a | |
99 // void (*) (const T&) function pointer, and calls the function with | |
100 // the parameter. | |
101 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
102 template <typename T> |
15396 | 103 class fcn_crefarg_elem : public elem |
104 { | |
105 public: | |
106 fcn_crefarg_elem (void (*fcn) (const T&), const T& arg) | |
107 : e_fcn (fcn), e_arg (arg) { } | |
108 | |
109 void run (void) { e_fcn (e_arg); } | |
110 | |
111 private: | |
112 void (*e_fcn) (const T&); | |
113 T e_arg; | |
114 }; | |
115 | |
116 // An element for calling a member function. | |
117 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
118 template <typename T> |
15396 | 119 class method_elem : public elem |
120 { | |
121 public: | |
122 method_elem (T *obj, void (T::*method) (void)) | |
123 : e_obj (obj), e_method (method) { } | |
124 | |
125 void run (void) { (e_obj->*e_method) (); } | |
126 | |
127 private: | |
128 | |
129 T *e_obj; | |
130 void (T::*e_method) (void); | |
131 | |
132 // No copying! | |
133 | |
134 method_elem (const method_elem&); | |
135 | |
136 method_elem operator = (const method_elem&); | |
137 }; | |
138 | |
139 // An element for calling a member function with a single argument | |
140 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
141 template <typename T, typename A> |
15396 | 142 class method_arg_elem : public elem |
143 { | |
144 public: | |
145 method_arg_elem (T *obj, void (T::*method) (A), A arg) | |
146 : e_obj (obj), e_method (method), e_arg (arg) { } | |
147 | |
148 void run (void) { (e_obj->*e_method) (e_arg); } | |
149 | |
150 private: | |
151 | |
152 T *e_obj; | |
153 void (T::*e_method) (A); | |
154 A e_arg; | |
155 | |
156 // No copying! | |
157 | |
158 method_arg_elem (const method_arg_elem&); | |
159 | |
160 method_arg_elem operator = (const method_arg_elem&); | |
161 }; | |
162 | |
163 // An element for calling a member function with a single argument | |
164 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
165 template <typename T, typename A> |
15396 | 166 class method_crefarg_elem : public elem |
167 { | |
168 public: | |
169 method_crefarg_elem (T *obj, void (T::*method) (const A&), const A& arg) | |
170 : e_obj (obj), e_method (method), e_arg (arg) { } | |
171 | |
172 void run (void) { (e_obj->*e_method) (e_arg); } | |
173 | |
174 private: | |
175 | |
176 T *e_obj; | |
177 void (T::*e_method) (const A&); | |
178 A e_arg; | |
179 | |
180 // No copying! | |
181 | |
182 method_crefarg_elem (const method_crefarg_elem&); | |
183 | |
184 method_crefarg_elem operator = (const method_crefarg_elem&); | |
185 }; | |
186 | |
187 // An element that stores arbitrary variable, and restores it. | |
188 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
189 template <typename T> |
15396 | 190 class restore_var_elem : public elem |
191 { | |
192 public: | |
193 restore_var_elem (T& ref, const T& val) | |
194 : e_ptr (&ref), e_val (val) { } | |
195 | |
196 void run (void) { *e_ptr = e_val; } | |
197 | |
198 private: | |
199 | |
200 // No copying! | |
201 | |
202 restore_var_elem (const restore_var_elem&); | |
203 | |
204 restore_var_elem& operator = (const restore_var_elem&); | |
205 | |
206 T *e_ptr, e_val; | |
207 }; | |
208 | |
209 // Deletes a class allocated using new. | |
210 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
211 template <typename T> |
15396 | 212 class delete_ptr_elem : public elem |
213 { | |
214 public: | |
215 delete_ptr_elem (T *ptr) | |
216 : e_ptr (ptr) { } | |
217 | |
218 void run (void) { delete e_ptr; } | |
219 | |
220 private: | |
221 | |
222 T *e_ptr; | |
223 | |
224 // No copying! | |
225 | |
226 delete_ptr_elem (const delete_ptr_elem&); | |
227 | |
228 delete_ptr_elem operator = (const delete_ptr_elem&); | |
229 }; | |
230 | |
231 action_container (void) { } | |
232 | |
233 virtual ~action_container (void) { } | |
234 | |
235 virtual void add (elem *new_elem) = 0; | |
236 | |
237 // Call to void func (void). | |
238 void add_fcn (void (*fcn) (void)) | |
239 { | |
240 add (new fcn_elem (fcn)); | |
241 } | |
242 | |
243 // Call to void func (T). | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
244 template <typename T> |
15396 | 245 void add_fcn (void (*action) (T), T val) |
246 { | |
247 add (new fcn_arg_elem<T> (action, val)); | |
248 } | |
249 | |
250 // Call to void func (const T&). | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
251 template <typename T> |
15396 | 252 void add_fcn (void (*action) (const T&), const T& val) |
253 { | |
254 add (new fcn_crefarg_elem<T> (action, val)); | |
255 } | |
256 | |
257 // Call to T::method (void). | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
258 template <typename T> |
15396 | 259 void add_method (T *obj, void (T::*method) (void)) |
260 { | |
261 add (new method_elem<T> (obj, method)); | |
262 } | |
263 | |
264 // Call to T::method (A). | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
265 template <typename T, typename A> |
15396 | 266 void add_method (T *obj, void (T::*method) (A), A arg) |
267 { | |
268 add (new method_arg_elem<T, A> (obj, method, arg)); | |
269 } | |
270 | |
271 // Call to T::method (const A&). | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
272 template <typename T, typename A> |
15396 | 273 void add_method (T *obj, void (T::*method) (const A&), const A& arg) |
274 { | |
275 add (new method_crefarg_elem<T, A> (obj, method, arg)); | |
276 } | |
277 | |
278 // Call to delete (T*). | |
279 | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
280 template <typename T> |
15396 | 281 void add_delete (T *obj) |
282 { | |
283 add (new delete_ptr_elem<T> (obj)); | |
284 } | |
285 | |
286 // Protect any variable. | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
287 template <typename T> |
15396 | 288 void protect_var (T& var) |
289 { | |
290 add (new restore_var_elem<T> (var, var)); | |
291 } | |
292 | |
293 // Protect any variable, value given. | |
21139
538b57866b90
consistently use "typename" intead of "class" in template declarations
John W. Eaton <jwe@octave.org>
parents:
20791
diff
changeset
|
294 template <typename T> |
15396 | 295 void protect_var (T& var, const T& val) |
296 { | |
297 add (new restore_var_elem<T> (var, val)); | |
298 } | |
299 | |
300 operator bool (void) const { return ! empty (); } | |
301 | |
302 virtual void run_first (void) = 0; | |
303 | |
304 void run (size_t num) | |
305 { | |
306 if (num > size ()) | |
307 num = size (); | |
308 | |
309 for (size_t i = 0; i < num; i++) | |
310 run_first (); | |
311 } | |
312 | |
313 void run (void) { run (size ()); } | |
314 | |
315 virtual void discard_first (void) = 0; | |
316 | |
317 void discard (size_t num) | |
318 { | |
319 if (num > size ()) | |
320 num = size (); | |
321 | |
322 for (size_t i = 0; i < num; i++) | |
323 discard_first (); | |
324 } | |
325 | |
326 void discard (void) { discard (size ()); } | |
327 | |
328 virtual size_t size (void) const = 0; | |
329 | |
330 bool empty (void) const { return size () == 0; } | |
331 | |
332 private: | |
333 | |
334 // No copying! | |
335 | |
336 action_container (const action_container&); | |
337 | |
338 action_container& operator = (const action_container&); | |
339 }; | |
340 | |
341 #endif |