Mercurial > octave-nkf
annotate liboctave/util/action-container.h @ 20651:e54ecb33727e
lo-array-gripes.cc: Remove FIXME's related to buffer size.
* lo-array-gripes.cc: Remove FIXME's related to buffer size. Shorten sprintf
buffers from 100 to 64 characters (still well more than 19 required).
Use 'const' decorator on constant value for clarity. Remove extra space
between variable and array bracket.
| author | Rik <rik@octave.org> |
|---|---|
| date | Mon, 12 Oct 2015 21:13:47 -0700 |
| parents | 4197fc428c7d |
| children |
| rev | line source |
|---|---|
| 15396 | 1 /* |
| 2 | |
|
19731
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 | |
| 24 #if !defined (octave_action_container_h) | |
| 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 | |
| 77 template <class T> | |
| 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 | |
| 102 template <class T> | |
| 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 | |
| 118 template <class T> | |
| 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 | |
| 141 template <class T, class A> | |
| 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 | |
| 165 template <class T, class A> | |
| 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 | |
| 189 template <class T> | |
| 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 | |
| 211 template <class T> | |
| 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). | |
| 244 template <class T> | |
| 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&). | |
| 251 template <class T> | |
| 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). | |
| 258 template <class T> | |
| 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). | |
| 265 template <class T, class A> | |
| 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&). | |
| 272 template <class T, class A> | |
| 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 | |
| 280 template <class T> | |
| 281 void add_delete (T *obj) | |
| 282 { | |
| 283 add (new delete_ptr_elem<T> (obj)); | |
| 284 } | |
| 285 | |
| 286 // Protect any variable. | |
| 287 template <class T> | |
| 288 void protect_var (T& var) | |
| 289 { | |
| 290 add (new restore_var_elem<T> (var, var)); | |
| 291 } | |
| 292 | |
| 293 // Protect any variable, value given. | |
| 294 template <class T> | |
| 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 |