source: issm/trunk/src/c/Container/Parameters.cpp@ 9320

Last change on this file since 9320 was 9320, checked in by Eric.Larour, 14 years ago

Quality control changes:

  • "stdlib" to <stdlib> and similar header file problems.
  • fscanf vulnerabilities issues.
File size: 12.8 KB
Line 
1/*
2 * \file Parameters.c
3 * \brief: implementation of the Parameters class, derived from DataSet class
4 */
5
6/*Headers: {{{1*/
7#ifdef HAVE_CONFIG_H
8 #include <config.h>
9#else
10#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
11#endif
12
13#include <vector>
14#include <functional>
15#include <algorithm>
16#include <iostream>
17
18#include "./DataSet.h"
19#include "../shared/shared.h"
20#include "../include/include.h"
21#include "../EnumDefinitions/EnumDefinitions.h"
22
23using namespace std;
24/*}}}*/
25
26/*Object constructors and destructor*/
27/*FUNCTION Parameters::Parameters(){{{1*/
28Parameters::Parameters(){
29 return;
30}
31/*}}}*/
32/*FUNCTION Parameters::Parameters(int in_enum){{{1*/
33Parameters::Parameters(int in_enum): DataSet(in_enum){
34 //do nothing;
35 return;
36}
37/*}}}*/
38/*FUNCTION Parameters::~Parameters(){{{1*/
39Parameters::~Parameters(){
40 return;
41}
42/*}}}*/
43
44/*Object management*/
45/*FUNCTION Parameters::Exist{{{1*/
46bool Parameters::Exist(int enum_type){
47
48 vector<Object*>::iterator object;
49 Param* param=NULL;
50
51 for ( object=objects.begin() ; object < objects.end(); object++ ){
52 param=(Param*)(*object);
53 if(param->EnumType()==enum_type) return true;
54 }
55 return false;
56}
57/*}}}*/
58/*FUNCTION Parameters::FindParam(bool* pbool,int enum_type){{{1*/
59void Parameters::FindParam(bool* pbool,int enum_type){ _assert_(this);
60
61 vector<Object*>::iterator object;
62 Param* param=NULL;
63
64 for ( object=objects.begin() ; object < objects.end(); object++ ){
65
66 param=(Param*)(*object);
67 if(param->EnumType()==enum_type){
68 param->GetParameterValue(pbool);
69 return;
70 }
71 }
72 _error_("could not find parameter %s",EnumToStringx(enum_type));
73}
74/*}}}*/
75/*FUNCTION Parameters::FindParam(int* pinteger,int enum_type){{{1*/
76void Parameters::FindParam(int* pinteger,int enum_type){ _assert_(this);
77
78 vector<Object*>::iterator object;
79 Param* param=NULL;
80
81 for ( object=objects.begin() ; object < objects.end(); object++ ){
82
83 param=(Param*)(*object);
84 if(param->EnumType()==enum_type){
85 param->GetParameterValue(pinteger);
86 return;
87 }
88 }
89 _error_("could not find parameter %s",EnumToStringx(enum_type));
90}
91/*}}}*/
92/*FUNCTION Parameters::FindParam(double* pscalar, int enum_type){{{1*/
93void Parameters::FindParam(double* pscalar, int enum_type){ _assert_(this);
94
95 vector<Object*>::iterator object;
96 Param* param=NULL;
97
98 for ( object=objects.begin() ; object < objects.end(); object++ ){
99
100 param=(Param*)(*object);
101 if(param->EnumType()==enum_type){
102 param->GetParameterValue(pscalar);
103 return;
104 }
105 }
106 _error_("could not find parameter %s",EnumToStringx(enum_type));
107}
108/*}}}*/
109/*FUNCTION Parameters::FindParam(char** pstring,int enum_type){{{1*/
110void Parameters::FindParam(char** pstring,int enum_type){ _assert_(this);
111
112 vector<Object*>::iterator object;
113 Param* param=NULL;
114
115 for ( object=objects.begin() ; object < objects.end(); object++ ){
116
117 param=(Param*)(*object);
118 if(param->EnumType()==enum_type){
119 param->GetParameterValue(pstring);
120 return;
121 }
122 }
123 _error_("could not find parameter %s",EnumToStringx(enum_type));
124
125}
126/*}}}*/
127/*FUNCTION Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){{{1*/
128void Parameters::FindParam(char*** pstringarray,int* pM,int enum_type){ _assert_(this);
129
130 vector<Object*>::iterator object;
131 Param* param=NULL;
132
133 for ( object=objects.begin() ; object < objects.end(); object++ ){
134
135 param=(Param*)(*object);
136 if(param->EnumType()==enum_type){
137 param->GetParameterValue(pstringarray,pM);
138 return;
139 }
140 }
141 _error_("could not find parameter %s",EnumToStringx(enum_type));
142
143}
144/*}}}*/
145/*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int enum_type){{{1*/
146void Parameters::FindParam(int** pintarray,int* pM, int enum_type){ _assert_(this);
147
148 vector<Object*>::iterator object;
149 Param* param=NULL;
150
151 for ( object=objects.begin() ; object < objects.end(); object++ ){
152
153 param=(Param*)(*object);
154 if(param->EnumType()==enum_type){
155 param->GetParameterValue(pintarray,pM);
156 return;
157 }
158 }
159 _error_("could not find parameter %s",EnumToStringx(enum_type));
160
161}
162/*}}}*/
163/*FUNCTION Parameters::FindParam(int** pintarray,int* pM,int* pN,int enum_type){{{1*/
164void Parameters::FindParam(int** pintarray,int* pM,int *pN,int enum_type){ _assert_(this);
165
166 vector<Object*>::iterator object;
167 Param* param=NULL;
168
169 for ( object=objects.begin() ; object < objects.end(); object++ ){
170
171 param=(Param*)(*object);
172 if(param->EnumType()==enum_type){
173 param->GetParameterValue(pintarray,pM,pN);
174 return;
175 }
176 }
177 _error_("could not find parameter %s",EnumToStringx(enum_type));
178
179}
180/*}}}*/
181/*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM,int enum_type){{{1*/
182void Parameters::FindParam(double** pdoublearray,int* pM, int enum_type){ _assert_(this);
183
184 vector<Object*>::iterator object;
185 Param* param=NULL;
186
187 for ( object=objects.begin() ; object < objects.end(); object++ ){
188
189 param=(Param*)(*object);
190 if(param->EnumType()==enum_type){
191 param->GetParameterValue(pdoublearray,pM);
192 return;
193 }
194 }
195 _error_("could not find parameter %s",EnumToStringx(enum_type));
196
197}
198/*}}}*/
199/*FUNCTION Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){{{1*/
200void Parameters::FindParam(double** pdoublearray,int* pM, int* pN,int enum_type){ _assert_(this);
201
202 vector<Object*>::iterator object;
203 Param* param=NULL;
204
205 for ( object=objects.begin() ; object < objects.end(); object++ ){
206
207 param=(Param*)(*object);
208 if(param->EnumType()==enum_type){
209 param->GetParameterValue(pdoublearray,pM,pN);
210 return;
211 }
212 }
213 _error_("could not find parameter %s",EnumToStringx(enum_type));
214
215}
216/*}}}*/
217/*FUNCTION Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){{{1*/
218void Parameters::FindParam(double*** parray,int* pM,int** pmdims_array,int** pndims_array,int enum_type){ _assert_(this);
219
220 vector<Object*>::iterator object;
221 Param* param=NULL;
222
223 for ( object=objects.begin() ; object < objects.end(); object++ ){
224
225 param=(Param*)(*object);
226 if(param->EnumType()==enum_type){
227 param->GetParameterValue(parray,pM,pmdims_array,pndims_array);
228 return;
229 }
230 }
231 _error_("could not find parameter %s",EnumToStringx(enum_type));
232}
233/*}}}*/
234/*FUNCTION Parameters::FindParam(Vec* pvec,int enum_type){{{1*/
235void Parameters::FindParam(Vec* pvec,int enum_type){ _assert_(this);
236
237 vector<Object*>::iterator object;
238 Param* param=NULL;
239
240 for ( object=objects.begin() ; object < objects.end(); object++ ){
241
242 param=(Param*)(*object);
243 if(param->EnumType()==enum_type){
244 param->GetParameterValue(pvec);
245 return;
246 }
247 }
248 _error_("could not find parameter %s",EnumToStringx(enum_type));
249
250}
251/*}}}*/
252/*FUNCTION Parameters::FindParam(Mat* pmat,int enum_type){{{1*/
253void Parameters::FindParam(Mat* pmat,int enum_type){ _assert_(this);
254
255 vector<Object*>::iterator object;
256 Param* param=NULL;
257
258 for ( object=objects.begin() ; object < objects.end(); object++ ){
259
260 param=(Param*)(*object);
261 if(param->EnumType()==enum_type){
262 param->GetParameterValue(pmat);
263 return;
264 }
265 }
266 _error_("could not find parameter %s",EnumToStringx(enum_type));
267
268}
269/*}}}*/
270/*FUNCTION Parameters::FindParam(FILE** pfid,int enum_type){{{1*/
271void Parameters::FindParam(FILE** pfid,int enum_type){ _assert_(this);
272
273 vector<Object*>::iterator object;
274 Param* param=NULL;
275
276 for ( object=objects.begin() ; object < objects.end(); object++ ){
277
278 param=(Param*)(*object);
279 if(param->EnumType()==enum_type){
280 param->GetParameterValue(pfid);
281 return;
282 }
283 }
284 _error_("could not find parameter %s",EnumToStringx(enum_type));
285}
286/*}}}*/
287
288/*FUNCTION Parameters::SetParam(bool boolean,int enum_type);{{{1*/
289void Parameters::SetParam(bool boolean,int enum_type){
290
291 Param* param=NULL;
292
293 /*first, figure out if the param has already been created: */
294 param=(Param*)this->FindParamObject(enum_type);
295
296 if(param) param->SetValue(boolean); //already exists, just set it.
297 else this->AddObject(new BoolParam(enum_type,boolean)); //just add the new parameter.
298}
299/*}}}*/
300/*FUNCTION Parameters::SetParam(int integer,int enum_type);{{{1*/
301void Parameters::SetParam(int integer,int enum_type){
302
303 Param* param=NULL;
304
305 /*first, figure out if the param has already been created: */
306 param=(Param*)this->FindParamObject(enum_type);
307
308 if(param) param->SetValue(integer); //already exists, just set it.
309 else this->AddObject(new IntParam(enum_type,integer)); //just add the new parameter.
310}
311/*}}}*/
312/*FUNCTION Parameters::SetParam(double scalar,int enum_type);{{{1*/
313void Parameters::SetParam(double scalar,int enum_type){
314
315 Param* param=NULL;
316
317 /*first, figure out if the param has already been created: */
318 param=(Param*)this->FindParamObject(enum_type);
319
320 if(param) param->SetValue(scalar); //already exists, just set it.
321 else this->AddObject(new DoubleParam(enum_type,scalar)); //just add the new parameter.
322}
323/*}}}*/
324/*FUNCTION Parameters::SetParam(char* string,int enum_type);{{{1*/
325void Parameters::SetParam(char* string,int enum_type){
326
327 Param* param=NULL;
328
329 /*first, figure out if the param has already been created: */
330 param=(Param*)this->FindParamObject(enum_type);
331
332 if(param) param->SetValue(string); //already exists, just set it.
333 else this->AddObject(new StringParam(enum_type,string)); //just add the new parameter.
334}
335/*}}}*/
336/*FUNCTION Parameters::SetParam(char** stringarray,int M, int enum_type);{{{1*/
337void Parameters::SetParam(char** stringarray,int M, int enum_type){
338
339 Param* param=NULL;
340
341 /*first, figure out if the param has already been created: */
342 param=(Param*)this->FindParamObject(enum_type);
343
344 if(param) param->SetValue(stringarray,M); //already exists, just set it.
345 else this->AddObject(new StringArrayParam(enum_type,stringarray,M)); //just add the new parameter.
346}
347/*}}}*/
348/*FUNCTION Parameters::SetParam(double* doublearray,int M,int enum_type);{{{1*/
349void Parameters::SetParam(double* doublearray,int M, int enum_type){
350
351 Param* param=NULL;
352
353 /*first, figure out if the param has already been created: */
354 param=(Param*)this->FindParamObject(enum_type);
355
356 if(param) param->SetValue(doublearray,M); //already exists, just set it.
357 else this->AddObject(new DoubleVecParam(enum_type,doublearray,M)); //just add the new parameter.
358}
359/*}}}*/
360/*FUNCTION Parameters::SetParam(double* doublearray,int M,int N, int enum_type);{{{1*/
361void Parameters::SetParam(double* doublearray,int M, int N, int enum_type){
362
363 Param* param=NULL;
364
365 /*first, figure out if the param has already been created: */
366 param=(Param*)this->FindParamObject(enum_type);
367
368 if(param) param->SetValue(doublearray,M,N); //already exists, just set it.
369 else this->AddObject(new DoubleMatParam(enum_type,doublearray,M,N)); //just add the new parameter.
370}
371/*}}}*/
372/*FUNCTION Parameters::SetParam(int* intarray,int M,int enum_type);{{{1*/
373void Parameters::SetParam(int* intarray,int M, int enum_type){
374
375 Param* param=NULL;
376
377 /*first, figure out if the param has already been created: */
378 param=(Param*)this->FindParamObject(enum_type);
379
380 if(param) param->SetValue(intarray,M); //already exists, just set it.
381 else this->AddObject(new IntVecParam(enum_type,intarray,M)); //just add the new parameter.
382}
383/*}}}*/
384/*FUNCTION Parameters::SetParam(int* intarray,int M,int N, int enum_type);{{{1*/
385void Parameters::SetParam(int* intarray,int M, int N, int enum_type){
386
387 Param* param=NULL;
388
389 /*first, figure out if the param has already been created: */
390 param=(Param*)this->FindParamObject(enum_type);
391
392 if(param) param->SetValue(intarray,M,N); //already exists, just set it.
393 else this->AddObject(new IntMatParam(enum_type,intarray,M,N)); //just add the new parameter.
394}
395/*}}}*/
396/*FUNCTION Parameters::SetParam(Vec vector,int enum_type);{{{1*/
397void Parameters::SetParam(Vec vector,int enum_type){
398
399 Param* param=NULL;
400
401 /*first, figure out if the param has already been created: */
402 param=(Param*)this->FindParamObject(enum_type);
403
404 if(param) param->SetValue(vector); //already exists, just set it.
405 else this->AddObject(new PetscVecParam(enum_type,vector)); //just add the new parameter.
406}
407/*}}}*/
408/*FUNCTION Parameters::SetParam(Mat matrix,int enum_type);{{{1*/
409void Parameters::SetParam(Mat matrix,int enum_type){
410
411 Param* param=NULL;
412
413 /*first, figure out if the param has already been created: */
414 param=(Param*)this->FindParamObject(enum_type);
415
416 if(param) param->SetValue(matrix); //already exists, just set it.
417 else this->AddObject(new PetscMatParam(enum_type,matrix)); //just add the new parameter.
418}
419/*}}}*/
420/*FUNCTION Parameters::SetParam(FILE* fid,int enum_type);{{{1*/
421void Parameters::SetParam(FILE* fid,int enum_type){
422
423 Param* param=NULL;
424
425 /*first, figure out if the param has already been created: */
426 param=(Param*)this->FindParamObject(enum_type);
427
428 if(param) param->SetValue(fid); //already exists, just set it.
429 else this->AddObject(new FileParam(enum_type,fid)); //just add the new parameter.
430}
431/*}}}*/
432
433/*FUNCTION Parameters::FindParamObject{{{1*/
434Object* Parameters::FindParamObject(int enum_type){
435
436 vector<Object*>::iterator object;
437 Param* param=NULL;
438
439 for ( object=objects.begin() ; object < objects.end(); object++ ){
440
441 param=(Param*)(*object);
442 if(param->EnumType()==enum_type){
443 return (*object);
444 }
445 }
446 return NULL;
447}
448/*}}}*/
Note: See TracBrowser for help on using the repository browser.