Branch data Line data Source code
1 : :
2 : : #include "CubitAttribManager.hpp"
3 : : #include "CubitAttribUser.hpp"
4 : : #include "CastTo.hpp"
5 : : #include "assert.h"
6 : : #include "CADefines.hpp"
7 : :
8 : : #include "RefEntity.hpp"
9 : : #include "CubitMessage.hpp"
10 : :
11 : 874 : CubitAttribManager::CubitAttribManager()
12 [ + - ][ + - ]: 874 : : silentFlag(false)
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
13 : : {
14 : 874 : }
15 : :
16 [ # # ][ # # ]: 0 : CubitAttribManager::~CubitAttribManager()
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
17 : : {
18 : : /*
19 : : std::map<int, CARegisterData*>::iterator iter = mTypeToCAData.begin();
20 : :
21 : : while (mTypeToCAData.end() != iter)
22 : : {
23 : : delete iter->second;
24 : : iter++;
25 : : }
26 : : */
27 : : int i;
28 [ # # ][ # # ]: 0 : assert(mTypeNames.size() == mInternalNames.size());
[ # # ]
29 : :
30 : :
31 [ # # ][ # # ]: 0 : for (i=mTypeNames.size(); i>0; i--)
32 : : {
33 [ # # ][ # # ]: 0 : delete [] mTypeNames.get_and_step();
34 [ # # ][ # # ]: 0 : delete [] mInternalNames.get_and_step();
35 : : }
36 : :
37 [ # # ]: 0 : }
38 : :
39 : : CubitStatus
40 : 13100 : CubitAttribManager::register_attrib_type( const int att_type,
41 : : const char* att_type_name,
42 : : const char* att_internal_name,
43 : : CACreateFunction p_create_function,
44 : : CubitBoolean auto_actuate_flag,
45 : : CubitBoolean auto_update_flag,
46 : : CubitBoolean auto_write_flag,
47 : : CubitBoolean auto_read_flag,
48 : : CubitBoolean actuate_in_constructor,
49 : : CubitBoolean actuate_after_geom_changes)
50 : : {
51 [ - + ]: 13100 : assert(CA_UNDEFINED != att_type);
52 [ - + ]: 13100 : assert(CA_ALL_ATTRIBUTES != att_type);
53 : :
54 : : /*
55 : : unsigned int flags = 0;
56 : : if (auto_actuate_flag) flags |= CA_AUTOACTUATE;
57 : : if (auto_update_flag) flags |= CA_AUTOUPDATE;
58 : : if (auto_write_flag) flags |= CA_AUTOWRITE;
59 : : if (auto_read_flag) flags |= CA_AUTOREAD;
60 : : if (actuate_in_constructor) flags |= CA_ACTUATEINCONSTRUCTOR;
61 : : if (actuate_after_geom_changes) flags |= CA_ACTUATEAFTERGEOMCHANGES;
62 : : CARegisterData *p_entry = new CARegisterData(att_type_name, att_internal_name,
63 : : p_create_function, flags);
64 : :
65 : : std::pair<std::map<int, CARegisterData*>::iterator, bool> result_pair;
66 : : result_pair = mTypeToCAData.insert( std::pair<int, CARegisterData*>(att_type, p_entry) );
67 : :
68 : : if (!result_pair.second) // failed to insert because the type was already registered
69 : : {
70 : : assert(false);
71 : : delete p_entry;
72 : : return CUBIT_FAILURE;
73 : : }
74 : : */
75 : :
76 [ + - ]: 13100 : int index = mTypes.where_is_item(att_type);
77 [ + + ]: 13100 : if (-1 != index) // type already registered
78 : : {
79 [ + - ][ + - ]: 11 : if (!silentFlag) PRINT_ERROR("Attribute type %d already registered\n.", att_type);
[ + - ][ + - ]
[ + - ]
80 : 11 : return CUBIT_FAILURE;
81 : : }
82 : :
83 : : #ifndef NDEBUG
84 [ + - ]: 13089 : int size = mTypes.size();
85 [ + - ][ - + ]: 13089 : assert (mTypeNames.size() == size);
86 [ + - ][ - + ]: 13089 : assert (mCreatorFunctions.size() == size);
87 [ + - ][ - + ]: 13089 : assert (mInternalNames.size() == size);
88 [ + - ][ - + ]: 13089 : assert (mAutoActuateFlags.size() == size);
89 [ + - ][ - + ]: 13089 : assert (mAutoUpdateFlags.size() == size);
90 [ + - ][ - + ]: 13089 : assert (mAutoWriteFlags.size() == size);
91 [ + - ][ - + ]: 13089 : assert (mAutoReadFlags.size() == size);
92 [ + - ][ - + ]: 13089 : assert (mActuateInConstructor.size() == size);
93 [ + - ][ - + ]: 13089 : assert (mActuateAfterGeomChanges.size() == size);
94 : : // assert (mAttribImported.size() == size);
95 : : #endif
96 : :
97 [ + - ]: 13089 : mTypes.append(att_type);
98 : :
99 : 13089 : int namesize = strlen(att_type_name);
100 [ + - ]: 13089 : char *stemp = new char[namesize+1];
101 : 13089 : strcpy(stemp, att_type_name);
102 [ + - ]: 13089 : mTypeNames.append(stemp);
103 : :
104 : 13089 : namesize = strlen(att_internal_name);
105 [ + - ]: 13089 : stemp = new char[namesize+1];
106 : 13089 : strcpy(stemp, att_internal_name);
107 [ + - ]: 13089 : mInternalNames.append(stemp);
108 : :
109 [ + - ]: 13089 : mCreatorFunctions.append(p_create_function);
110 : :
111 [ + - ]: 13089 : mAutoActuateFlags.append(auto_actuate_flag);
112 [ + - ]: 13089 : mAutoUpdateFlags.append(auto_update_flag);
113 [ + - ]: 13089 : mAutoWriteFlags.append(auto_write_flag);
114 [ + - ]: 13089 : mAutoReadFlags.append(auto_read_flag);
115 [ + - ]: 13089 : mActuateInConstructor.append(actuate_in_constructor);
116 [ + - ]: 13089 : mActuateAfterGeomChanges.append(actuate_after_geom_changes);
117 : : // mAttribImported.append(CUBIT_FALSE); // TODO - get rid of mAttribImported
118 : :
119 : 13100 : return CUBIT_SUCCESS;
120 : : }
121 : :
122 : : CubitAttrib*
123 : 298794 : CubitAttribManager::create_cubit_attrib(const int attrib_type,
124 : : RefEntity *attrib_user,
125 : : const CubitSimpleAttrib &p_csa)
126 : : {
127 : 298794 : CubitAttrib* new_attrib = NULL;
128 : : /*
129 : : CARegisterData *p_entry = NULL;
130 : : CACreateFunction p_creator;
131 : : std::map<int, CARegisterData*>::iterator iter;
132 : :
133 : : iter = mTypeToCAData.find(attrib_type);
134 : : if (mTypeToCAData.end() == iter)
135 : : {
136 : : assert(false);
137 : : return NULL;
138 : : }
139 : :
140 : : p_entry = iter->second;
141 : : p_creator = p_entry->mCreateFunction;
142 : : new_attrib = (*p_creator)(attrib_user);
143 : : return new_attrib;
144 : : */
145 : :
146 : 298794 : int index = mTypes.where_is_item(attrib_type);
147 [ - + ]: 298794 : if (-1 == index) // type not registered
148 : : {
149 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Attribute type %d can't be created because it hasn't been registered.\n",
150 [ # # ]: 0 : attrib_type);
151 : 0 : return NULL;
152 : : }
153 : :
154 : :
155 : : CACreateFunction p_creator;
156 : 298794 : mCreatorFunctions.reset();
157 : 298794 : p_creator = mCreatorFunctions.next(index);
158 : :
159 : 298794 : new_attrib = (*p_creator)(attrib_user, p_csa);
160 : 298794 : return new_attrib;
161 : :
162 : : }
163 : :
164 : : /*
165 : : CubitStatus CubitAttribManager::actuate_list(DLIList<RefEntity*> entity_list)
166 : : {
167 : : int i, j;
168 : : RefEntity * ref_ent;
169 : : for(i = entity_list.size(); i > 0; i--)
170 : : {
171 : : ref_ent = entity_list.get_and_step();
172 : :
173 : : mTypes.reset();
174 : : for (j = mTypes.size(); j>0; j--)
175 : : {
176 : : ref_ent->actuate_cubit_attrib(mTypes.get_and_step());
177 : : }
178 : : }
179 : : return CUBIT_SUCCESS;
180 : : }
181 : : */
182 : 32396 : CubitStatus CubitAttribManager::auto_update_attribs(RefEntity *cau)
183 : : {
184 : : //- create attribs whose auto update flag is set
185 : :
186 : 32396 : CubitStatus status = CUBIT_SUCCESS;
187 [ + - ]: 32396 : DLIList<CubitAttrib*> attrib_list;
188 : :
189 : : /*
190 : : std::map<int, CARegisterData*>::iterator iter = mTypeToCAData.begin();
191 : :
192 : : while (mTypeToCAData.end() != iter)
193 : : {
194 : : CubitBoolean auto_update = ((iter->second)->flags) & CA_AUTOUPDATE;
195 : : int attrib_type = iter->first;
196 : :
197 : : if (auto_update)
198 : : {
199 : : attrib_list.clean_out();
200 : : cau->find_cubit_attrib_type(attrib_type, attrib_list);
201 : : if (attrib_list.size() == 0) {
202 : : create_cubit_attrib(attrib_type, cau);
203 : : if (status == CUBIT_FAILURE) break;
204 : : }
205 : : }
206 : : iter++;
207 : : }
208 : : */
209 [ + - ]: 32396 : mAutoUpdateFlags.reset();
210 [ + - ]: 32396 : mTypes.reset();
211 [ + - ][ + - ]: 32396 : assert(mTypes.size() == mAutoUpdateFlags.size());
[ - + ]
212 : : int index;
213 [ + - ][ + + ]: 526059 : for (index=mAutoUpdateFlags.size(); index>0; index--) {
214 : : // check the auto update flag first, if not set we can go
215 [ + - ][ + - ]: 493663 : if (mAutoUpdateFlags.get() == CUBIT_TRUE)
[ + + ]
216 : : {
217 : :
218 : : // else we must create a CA of type if there's not one already there
219 [ + - ]: 231436 : attrib_list.clean_out();
220 [ + - ][ + - ]: 231436 : cau->find_cubit_attrib_type(mTypes.get(), attrib_list);
221 [ + - ][ + + ]: 231436 : if (attrib_list.size() == 0) {
222 [ + - ][ + - ]: 218828 : create_cubit_attrib(mTypes.get(), cau, CubitSimpleAttrib());
[ + - ][ + - ]
223 [ - + ]: 218828 : if (status == CUBIT_FAILURE) break;
224 : : }
225 : : }
226 [ + - ]: 493663 : mAutoUpdateFlags.step();
227 [ + - ]: 493663 : mTypes.step();
228 : : }
229 : :
230 [ + - ]: 32396 : return status;
231 : : }
232 : :
233 : 360 : void CubitAttribManager::set_all_auto_actuate_flags(CubitBoolean value)
234 : : {
235 : :
236 : : // std::map<int, CARegisterData*>::iterator iter = mTypeToCAData.begin();
237 : :
238 : : // while (mTypeToCAData.end() != iter)
239 : : // {
240 : :
241 : 360 : mAutoActuateFlags.reset();
242 [ + + ]: 5841 : for (int i = mAutoActuateFlags.size(); i>0; i--)
243 : : {
244 : 5481 : mAutoActuateFlags.change_to(value);
245 : 5481 : mAutoActuateFlags.step();
246 : : }
247 : 360 : }
248 : :
249 : 6720 : CubitStatus CubitAttribManager::set_auto_actuate_flag(int attrib_type, CubitBoolean value)
250 : : {
251 [ - + ]: 6720 : assert(CA_UNDEFINED != attrib_type);
252 [ - + ]: 6720 : assert(CA_ALL_ATTRIBUTES != attrib_type);
253 : :
254 : 6720 : int index = mTypes.where_is_item(attrib_type);
255 : :
256 [ + + ]: 6720 : if (-1 == index)
257 : 717 : return CUBIT_FAILURE;
258 : :
259 : 6003 : mAutoActuateFlags.reset();
260 : 6003 : mAutoActuateFlags.step(index);
261 : 6003 : mAutoActuateFlags.change_to(value);
262 : 6003 : return CUBIT_SUCCESS;
263 : : }
264 : :
265 : 120 : void CubitAttribManager::set_all_auto_update_flags(CubitBoolean value)
266 : : {
267 : 120 : mAutoUpdateFlags.reset();
268 [ + + ]: 1941 : for (int i = mAutoUpdateFlags.size(); i>0; i--)
269 : : {
270 : 1821 : mAutoUpdateFlags.change_to(value);
271 : 1821 : mAutoUpdateFlags.step();
272 : : }
273 : 120 : }
274 : :
275 : 6720 : CubitStatus CubitAttribManager::set_auto_update_flag(int attrib_type, CubitBoolean value)
276 : : {
277 [ - + ]: 6720 : assert(CA_UNDEFINED != attrib_type);
278 [ - + ]: 6720 : assert(CA_ALL_ATTRIBUTES != attrib_type);
279 : :
280 : 6720 : int index = mTypes.where_is_item(attrib_type);
281 : :
282 [ + + ]: 6720 : if (-1 == index)
283 : 717 : return CUBIT_FAILURE;
284 : :
285 : 6003 : mAutoUpdateFlags.reset();
286 : 6003 : mAutoUpdateFlags.step(index);
287 : 6003 : mAutoUpdateFlags.change_to(value);
288 : 6003 : return CUBIT_SUCCESS;
289 : : }
290 : :
291 : 120 : void CubitAttribManager::set_all_auto_write_flags(CubitBoolean value)
292 : : {
293 : 120 : mAutoWriteFlags.reset();
294 [ + + ]: 1941 : for (int i = mAutoWriteFlags.size(); i>0; i--)
295 : : {
296 : 1821 : mAutoWriteFlags.change_to(value);
297 : 1821 : mAutoWriteFlags.step();
298 : : }
299 : 120 : }
300 : :
301 : 6720 : CubitStatus CubitAttribManager::set_auto_write_flag(int attrib_type, CubitBoolean value)
302 : : {
303 [ - + ]: 6720 : assert(CA_UNDEFINED != attrib_type);
304 [ - + ]: 6720 : assert(CA_ALL_ATTRIBUTES != attrib_type);
305 : :
306 : 6720 : int index = mTypes.where_is_item(attrib_type);
307 : :
308 [ + + ]: 6720 : if (-1 == index)
309 : 717 : return CUBIT_FAILURE;
310 : :
311 : 6003 : mAutoWriteFlags.reset();
312 : 6003 : mAutoWriteFlags.step(index);
313 : 6003 : mAutoWriteFlags.change_to(value);
314 : 6003 : return CUBIT_SUCCESS;
315 : : }
316 : :
317 : 360 : void CubitAttribManager::set_all_auto_read_flags(CubitBoolean value)
318 : : {
319 : 360 : mAutoReadFlags.reset();
320 [ + + ]: 5841 : for (int i = mAutoReadFlags.size(); i>0; i--)
321 : : {
322 : 5481 : mAutoReadFlags.change_to(value);
323 : 5481 : mAutoReadFlags.step();
324 : : }
325 : 360 : }
326 : :
327 : 6720 : CubitStatus CubitAttribManager::set_auto_read_flag(int attrib_type, CubitBoolean value)
328 : : {
329 [ - + ]: 6720 : assert(CA_UNDEFINED != attrib_type);
330 [ - + ]: 6720 : assert(CA_ALL_ATTRIBUTES != attrib_type);
331 : :
332 : 6720 : int index = mTypes.where_is_item(attrib_type);
333 : :
334 [ + + ]: 6720 : if (-1 == index)
335 : 717 : return CUBIT_FAILURE;
336 : :
337 : 6003 : mAutoReadFlags.reset();
338 : 6003 : mAutoReadFlags.step(index);
339 : 6003 : mAutoReadFlags.change_to(value);
340 : 6003 : return CUBIT_SUCCESS;
341 : : }
342 : :
343 : 717 : void CubitAttribManager::auto_flag(int flag)
344 : : {
345 [ - + ]: 717 : if (flag == -1) {
346 : 0 : flag = auto_flag();
347 [ # # ]: 0 : if (flag == -1) {
348 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Can't change attribute flag with toggle, "
349 [ # # ]: 0 : "some are already set.\n");
350 : 717 : return;
351 : : }
352 : : }
353 : :
354 [ + - ]: 717 : CubitBoolean set_flag = (flag == 1 ? CUBIT_TRUE : CUBIT_FALSE);
355 : :
356 : 717 : mAutoUpdateFlags.reset();
357 : 717 : mAutoActuateFlags.reset();
358 [ - + ]: 717 : assert (mAutoUpdateFlags.size() == mAutoActuateFlags.size());
359 [ + + ]: 11671 : for (int i = mAutoUpdateFlags.size(); i>0; i--)
360 : : {
361 : 10954 : mAutoUpdateFlags.change_to(set_flag);
362 : 10954 : mAutoUpdateFlags.step();
363 : 10954 : mAutoActuateFlags.change_to(set_flag);
364 : 10954 : mAutoActuateFlags.step();
365 : : }
366 : :
367 [ - + ]: 717 : if (!set_flag) {
368 : : // make sure entity_name flag isn't set false here
369 : :
370 [ # # ]: 0 : int index = mTypes.where_is_item(CA_ENTITY_NAME);
371 [ # # ]: 0 : assert(-1 != index);
372 : :
373 : 0 : mAutoUpdateFlags.reset();
374 : 0 : mAutoUpdateFlags.step(index);
375 : 0 : mAutoUpdateFlags.change_to(CUBIT_TRUE);
376 : :
377 : 0 : mAutoActuateFlags.reset();
378 : 0 : mAutoActuateFlags.step(index);
379 : 0 : mAutoActuateFlags.change_to(CUBIT_TRUE);
380 : : }
381 : : }
382 : :
383 : 0 : int CubitAttribManager::auto_flag()
384 : : {
385 : 0 : int sum = 0;
386 : : CubitBoolean b_temp;
387 : 0 : mAutoUpdateFlags.reset();
388 : 0 : mAutoActuateFlags.reset();
389 [ # # ]: 0 : assert (mAutoUpdateFlags.size() == mAutoActuateFlags.size());
390 [ # # ]: 0 : for (int i = mAutoUpdateFlags.size(); i>0; i--)
391 : : {
392 [ # # ]: 0 : b_temp = mAutoUpdateFlags.get_and_step();
393 [ # # ]: 0 : if (b_temp) sum++;
394 [ # # ]: 0 : b_temp = mAutoActuateFlags.get_and_step();
395 [ # # ]: 0 : if (b_temp) sum++;
396 : : }
397 : :
398 [ # # ]: 0 : if (2*mAutoUpdateFlags.size() == sum) return 0;
399 [ # # ]: 0 : else if (sum == 0) return 1;
400 : 0 : else return -1;
401 : : }
402 : :
403 : 0 : int CubitAttribManager::attrib_type(const char* name)
404 : : {
405 : : int i;
406 : 0 : mTypeNames.reset();
407 [ # # ]: 0 : assert (mTypes.size() == mTypeNames.size());
408 [ # # ]: 0 : for (i=0; i<mTypeNames.size(); i++)
409 : : {
410 [ # # ]: 0 : if (!strcmp(name, mTypeNames.get_and_step()))
411 : : {
412 : 0 : mTypes.reset();
413 : 0 : mTypes.step(i);
414 : 0 : return mTypes.get();
415 : : }
416 : : }
417 : :
418 : 0 : return CA_UNDEFINED;
419 : : }
420 : :
421 : 5305 : int CubitAttribManager::attrib_type(const CubitSimpleAttrib& csa_ptr)
422 : : {
423 [ + - ]: 5305 : CubitString char_type = csa_ptr.character_type();
424 [ + - ][ + - ]: 5305 : return attrib_type_from_internal_name(char_type.c_str());
[ + - ]
425 : : }
426 : :
427 : 20589 : int CubitAttribManager::attrib_type_from_internal_name(const char* name)
428 : : {
429 : : int i;
430 : 20589 : mInternalNames.reset();
431 [ - + ]: 20589 : assert (mTypes.size() == mInternalNames.size());
432 [ + - ]: 73412 : for (i=0; i<mInternalNames.size(); i++)
433 : : {
434 [ + + ]: 73412 : if (!strcmp(name, mInternalNames.get_and_step()))
435 : : {
436 : 20589 : mTypes.reset();
437 : 20589 : mTypes.step(i);
438 : 20589 : return mTypes.get();
439 : : }
440 : : }
441 : :
442 : 0 : return CA_UNDEFINED;
443 : : }
444 : :
445 : 104432 : CubitBoolean CubitAttribManager::auto_actuate_flag(int attrib_type)
446 : : {
447 : 104432 : int index = mTypes.where_is_item(attrib_type);
448 [ + + ]: 104432 : if (-1 == index) {
449 [ + - ][ + - ]: 209 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ + - ]
450 : 209 : return false;
451 : : }
452 : :
453 : 104223 : mAutoActuateFlags.reset();
454 : 104223 : mAutoActuateFlags.step(index);
455 [ + - ]: 104432 : return mAutoActuateFlags.get();
456 : : }
457 : :
458 : 396675 : CubitBoolean CubitAttribManager::auto_update_flag(int attrib_type)
459 : : {
460 : 396675 : int index = mTypes.where_is_item(attrib_type);
461 [ + + ]: 396675 : if (-1 == index) {
462 [ + - ][ + - ]: 275 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ + - ]
463 : 275 : return false;
464 : : }
465 : :
466 : 396400 : mAutoUpdateFlags.reset();
467 : 396400 : mAutoUpdateFlags.step(index);
468 [ + - ]: 396675 : return mAutoUpdateFlags.get();
469 : : }
470 : :
471 : 32290 : CubitBoolean CubitAttribManager::auto_write_flag(int attrib_type)
472 : : {
473 : 32290 : int index = mTypes.where_is_item(attrib_type);
474 [ - + ]: 32290 : if (-1 == index) {
475 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ # # ]
476 : 0 : return false;
477 : : }
478 : :
479 : 32290 : mAutoWriteFlags.reset();
480 : 32290 : mAutoWriteFlags.step(index);
481 [ + - ]: 32290 : return mAutoWriteFlags.get();
482 : : }
483 : :
484 : 12430 : CubitBoolean CubitAttribManager::auto_read_flag(int attrib_type)
485 : : {
486 : 12430 : int index = mTypes.where_is_item(attrib_type);
487 [ - + ]: 12430 : if (-1 == index) {
488 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ # # ]
489 : 0 : return false;
490 : : }
491 : :
492 : 12430 : mAutoReadFlags.reset();
493 : 12430 : mAutoReadFlags.step(index);
494 [ + - ]: 12430 : return mAutoReadFlags.get();
495 : : }
496 : :
497 : : //- return the internal name of this CA given the enumerated attribute type
498 : 261951 : const char * CubitAttribManager::att_internal_name(int attrib_type)
499 : : {
500 : 261951 : int index = mTypes.where_is_item(attrib_type);
501 [ - + ]: 261951 : if (-1 == index) {
502 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ # # ]
503 : 0 : return NULL;
504 : : }
505 : :
506 : 261951 : mInternalNames.reset();
507 : 261951 : mInternalNames.step(index);
508 : 261951 : return mInternalNames.get();
509 : : }
510 : :
511 : : //- return the name of this CA given the enumerated attribute type
512 : 0 : const char * CubitAttribManager::att_name(int attrib_type)
513 : : {
514 : 0 : int index = mTypes.where_is_item(attrib_type);
515 [ # # ]: 0 : if (-1 == index) {
516 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ # # ]
517 : 0 : return NULL;
518 : : }
519 : :
520 : 0 : mTypeNames.reset();
521 : 0 : mTypeNames.step(index);
522 : 0 : return mTypeNames.get();
523 : : }
524 : :
525 : 6317 : CubitBoolean CubitAttribManager::actuate_in_constructor(int attrib_type)
526 : : {
527 : 6317 : int index = mTypes.where_is_item(attrib_type);
528 [ - + ]: 6317 : if (-1 == index) {
529 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ # # ]
530 : 0 : return false;
531 : : }
532 : :
533 : 6317 : mActuateInConstructor.reset();
534 : 6317 : mActuateInConstructor.step(index);
535 [ + - ]: 6317 : return mActuateInConstructor.get();
536 : : }
537 : :
538 : 7621 : CubitBoolean CubitAttribManager::actuate_after_geom_changes(int attrib_type)
539 : : {
540 : 7621 : int index = mTypes.where_is_item(attrib_type);
541 [ - + ]: 7621 : if (-1 == index) {
542 [ # # ][ # # ]: 0 : if (!silentFlag) PRINT_ERROR("Attribute type %d not recognized.\n", attrib_type);
[ # # ]
543 : 0 : return false;
544 : : }
545 : :
546 : 7621 : mActuateAfterGeomChanges.reset();
547 : 7621 : mActuateAfterGeomChanges.step(index);
548 [ + - ]: 7621 : return mActuateAfterGeomChanges.get();
549 : : }
550 : :
551 : 1112 : void CubitAttribManager::get_registered_types(DLIList<int> &types)
552 : : {
553 : 1112 : types = mTypes;
554 : 1112 : types.reset();
555 [ + - ][ + - ]: 6540 : }
556 : :
557 : :
|
