Branch data Line data Source code
1 : : //- Class: CAGroup
2 : : //- Owner: Greg Nielson
3 : : //- Description: Cubit Attribute for groups.
4 : : //- Checked By:
5 : : //- Version:
6 : :
7 : : #include "CAGroup.hpp"
8 : : #include "RefEntity.hpp"
9 : : #include "RefEntityFactory.hpp"
10 : : #include "RefGroup.hpp"
11 : : #include "CubitObserver.hpp"
12 : : #include "DLIList.hpp"
13 : : #include "CastTo.hpp"
14 : : #include "TDCAGE.hpp"
15 : : #include "GeometryQueryTool.hpp"
16 : :
17 : : #include <stdlib.h>
18 : : #include <time.h>
19 : :
20 : : // initialize this CA's static members
21 : : CubitBoolean CAGroup::initialize_rand = CUBIT_TRUE;
22 : :
23 : 6367 : CubitAttrib* CAGroup_creator(RefEntity* entity, const CubitSimpleAttrib &p_csa)
24 : : {
25 [ + - ]: 6367 : return new CAGroup(entity, p_csa);
26 : : }
27 : :
28 : 6367 : CAGroup::CAGroup(RefEntity* new_attrib_owner,
29 : : const CubitSimpleAttrib& csa_ptr)
30 [ + - ][ + - ]: 6367 : : CubitAttrib(new_attrib_owner)
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
31 : : {
32 : :
33 [ + - ]: 6367 : initialize();
34 : :
35 [ + - ][ + + ]: 6367 : if(!csa_ptr.isEmpty())
36 : : {
37 : :
38 [ + - ]: 11 : const std::vector<int>& i_list = csa_ptr.int_data_list();
39 [ + - ]: 11 : const std::vector<CubitString>& cs_list = csa_ptr.string_data_list();
40 : :
41 : : // first, the ints
42 : :
43 : 11 : int offset = 0;
44 [ + - ]: 11 : int num_groups = i_list[offset++];
45 : :
46 : : // groupID
47 : : int i;
48 [ + + ]: 22 : for (i = num_groups; i > 0; i--)
49 [ + - ][ + - ]: 11 : groupID.append(i_list[offset++]);
50 : :
51 : : // uniqueID
52 [ + + ]: 22 : for (i = num_groups; i > 0; i--)
53 [ + - ][ + - ]: 11 : uniqueID.append(i_list[offset++]);
54 : :
55 : : // sequenceNumbers
56 [ + + ]: 22 : for (i = num_groups; i > 0; i--)
57 [ + - ][ + - ]: 11 : sequenceNumbers.append(i_list[offset++]);
58 : :
59 : : // numOwningGroups
60 [ + + ]: 22 : for (i = num_groups; i > 0; i--)
61 [ + - ][ + - ]: 11 : numOwningGroups.append(i_list[offset++]);
62 : :
63 : : // total number of owning groups
64 [ + - ]: 11 : int total_owning_groups = i_list[offset++];
65 : :
66 : : // owningGroupID
67 [ - + ]: 11 : for (i = total_owning_groups; i > 0; i--)
68 [ # # ][ # # ]: 0 : owningGroupID.append(i_list[offset++]);
69 : :
70 : : // owningUniqueID
71 [ - + ]: 11 : for (i = total_owning_groups; i > 0; i--)
72 [ # # ][ # # ]: 0 : owningUniqueID.append(i_list[offset++]);
73 : :
74 : : // owningSequenceNumbers
75 [ - + ]: 11 : for (i = total_owning_groups; i > 0; i--)
76 [ # # ][ # # ]: 0 : owningSequenceNumbers.append(i_list[offset++]);
77 : :
78 : : // ancestor groups added after first implementation of CAGroup,
79 : : // therefore not all attributes may have ancestor groups
80 : : // setting total_ancestor_groups to zero first will short-circuit
81 : : // loops below if there aren't any ancestor groups, so no need for
82 : : // an 'if' statement
83 : :
84 : : // total number of ancestor groups
85 : 11 : int total_ancestor_groups = 0;
86 : :
87 [ + - ][ + - ]: 11 : if (i_list.size() > (size_t)(4*num_groups + 3*total_owning_groups + 2))
88 [ + - ]: 11 : total_ancestor_groups = i_list[offset++];
89 : :
90 : : // ancestorGroupID
91 [ - + ]: 11 : for (i = total_ancestor_groups; i > 0; i--)
92 [ # # ][ # # ]: 0 : ancestorGroupID.append(i_list[offset++]);
93 : :
94 : : // ancestorUniqueID
95 [ - + ]: 11 : for (i = total_ancestor_groups; i > 0; i--)
96 [ # # ][ # # ]: 0 : ancestorUniqueID.append(i_list[offset++]);
97 : :
98 : : // ancestorOwnedGroupUid
99 [ - + ]: 11 : for (i = total_ancestor_groups; i > 0; i--)
100 [ # # ][ # # ]: 0 : ancestorOwnedGroupUid.append(i_list[offset++]);
101 : :
102 : : // ancestorSequenceNumbers
103 [ - + ]: 11 : for (i = total_ancestor_groups; i > 0; i--)
104 [ # # ][ # # ]: 0 : ancestorSequenceNumbers.append(i_list[offset++]);
105 : :
106 : : // now, doubles (none)
107 : :
108 : : // now, strings
109 : : // attribute internal name (just pop the list)
110 : 11 : offset = 1;
111 : :
112 : : // groupNames
113 [ + + ]: 22 : for (i = num_groups; i > 0; i--)
114 [ + - ][ + - ]: 11 : groupNames.append(cs_list[offset++]);
115 : :
116 : : // owningGroupNames
117 [ - + ]: 11 : for (i = total_owning_groups; i > 0; i--)
118 [ # # ][ # # ]: 0 : owningGroupNames.append(cs_list[offset++]);
119 : :
120 : : // ancestorGroupName
121 [ - + ]: 11 : for (i = total_ancestor_groups; i > 0; i--)
122 [ # # ][ # # ]: 0 : ancestorGroupName.append(cs_list[offset++]);
123 : :
124 : : // ok, we're done
125 : : }
126 : 6367 : }
127 : :
128 [ + - ][ + - ]: 19101 : CAGroup::~CAGroup()
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
129 : : {
130 [ - + ]: 12734 : }
131 : :
132 : 6367 : void CAGroup::initialize()
133 : : {
134 [ + + ]: 6367 : if(initialize_rand == CUBIT_TRUE)
135 : : {
136 : : #if defined _WIN32 || defined CUBIT_LINUX
137 : 76 : srand((unsigned)time(NULL));
138 : : #else
139 : : srand48(time(NULL));
140 : : #endif
141 : 76 : initialize_rand = CUBIT_FALSE;
142 : : }
143 : 6367 : }
144 : :
145 : :
146 : :
147 : 11 : CubitStatus CAGroup::actuate()
148 : : {
149 [ - + ]: 11 : if (hasActuated == CUBIT_TRUE) return CUBIT_SUCCESS;
150 : :
151 : : // need to reset all the lists to keep them in sync
152 : 11 : groupID.reset();
153 : 11 : uniqueID.reset();
154 : 11 : groupNames.reset();
155 : 11 : sequenceNumbers.reset();
156 : 11 : owningGroupID.reset();
157 : 11 : owningUniqueID.reset();
158 : 11 : owningGroupNames.reset();
159 : 11 : owningSequenceNumbers.reset();
160 : 11 : numOwningGroups.reset();
161 : :
162 : : // go through all the groups on this CA
163 : : int i;
164 [ + + ]: 22 : for (i = groupID.size(); i > 0; i--) {
165 : : // pop the data for this group off the lists
166 [ + - ]: 11 : int group_id = groupID.get_and_step();
167 [ + - ]: 11 : int unique_id = uniqueID.get_and_step();
168 [ + - ][ + - ]: 11 : CubitString group_name = groupNames.get_and_step();
169 [ + - ]: 11 : int seq_num = sequenceNumbers.get_and_step();
170 : :
171 : : RefGroup *ref_group =
172 : : assign_group(attribOwnerEntity, group_id, unique_id,
173 [ + - ]: 11 : group_name, seq_num);
174 : :
175 : :
176 : : // check for groups owning this group
177 [ + - ]: 11 : int owning_groups = numOwningGroups.get_and_step();
178 : :
179 [ - + ]: 11 : for (int j = owning_groups; j > 0; j--)
180 : : {
181 [ # # ]: 0 : int owning_group_id = owningGroupID.get_and_step();
182 [ # # ]: 0 : int owning_unique_id = owningUniqueID.get_and_step();
183 [ # # ][ # # ]: 0 : CubitString owning_group_name = owningGroupNames.get_and_step();
184 [ # # ]: 0 : seq_num = owningSequenceNumbers.get_and_step();
185 : :
186 : : assign_group(ref_group, owning_group_id, owning_unique_id,
187 [ # # ]: 0 : owning_group_name, seq_num);
188 [ # # ]: 0 : }
189 : :
190 [ + - ]: 11 : } // loop over all groups in this CAGroup
191 : :
192 : : // now do ancestors
193 : 11 : ancestorGroupID.reset();
194 : 11 : ancestorUniqueID.reset();
195 : 11 : ancestorOwnedGroupUid.reset();
196 : 11 : ancestorGroupName.reset();
197 : 11 : ancestorSequenceNumbers.reset();
198 : :
199 [ - + ]: 11 : for (i = ancestorGroupID.size(); i > 0; i--) {
200 : : /*RefGroup *ancestor_group = */
201 : 0 : assign_ancestor_group(ancestorGroupID.get_and_step(),
202 : 0 : ancestorUniqueID.get_and_step(),
203 : 0 : ancestorGroupName.get_and_step(),
204 : 0 : ancestorOwnedGroupUid.get_and_step(),
205 : 0 : ancestorSequenceNumbers.get_and_step());
206 : : }
207 : :
208 : 11 : deleteAttrib = CUBIT_TRUE;
209 : 11 : hasActuated = CUBIT_TRUE;
210 : :
211 : 11 : return CUBIT_SUCCESS;
212 : : }
213 : :
214 : 11 : RefGroup *CAGroup::assign_group(RefEntity *owned_entity,
215 : : const int group_id, const int unique_id,
216 : : const CubitString& group_name,
217 : : const int seq_num)
218 : : {
219 : 11 : RefGroup* parent_group = NULL;
220 : 11 : CubitBoolean group_id_exists = CUBIT_FALSE;
221 : :
222 : : // search for the group corresponding to this id and unique id
223 : 11 : RefGroup *ref_group = GeometryQueryTool::instance()->get_last_ref_group();
224 [ - + ][ # # ]: 11 : for(int i = GeometryQueryTool::instance()->num_ref_groups(); i > 0 && !parent_group; i--)
225 : : {
226 : 0 : ref_group = GeometryQueryTool::instance()->get_next_ref_group();
227 [ # # ]: 0 : if(ref_group->id() == group_id)
228 : : {
229 : 0 : group_id_exists = CUBIT_TRUE;
230 : : }
231 : :
232 : 0 : ToolData *td_temp = ref_group->get_TD(&TDCAGE::is_cage);
233 [ # # ][ # # ]: 0 : TDCAGE *td_cagroup = (td_temp ? CAST_TO(td_temp, TDCAGE) : NULL);
234 [ # # ][ # # ]: 0 : if (td_cagroup != NULL && td_cagroup->unique_id() == unique_id)
[ # # ]
235 : 0 : parent_group = ref_group;
236 : : }
237 : :
238 [ + - ]: 11 : if(!parent_group)
239 : : {
240 : : // else make a new group, and assign id and unique id
241 : : // also assign group name
242 : 11 : parent_group = RefEntityFactory::instance()->construct_RefGroup();
243 [ + - ]: 11 : if(!group_id_exists) {
244 : 11 : parent_group->set_id(0);
245 : 11 : parent_group->set_id(group_id);
246 : : }
247 : : else
248 [ # # ]: 0 : PRINT_INFO("Creating group %d to hold attribute group %d\n",
249 [ # # ]: 0 : parent_group->id(), group_id);
250 : :
251 : : // put a td on this new group with the right unique_id
252 [ + - ]: 11 : TDCAGE *td_cagroup = new TDCAGE(unique_id);
253 : 11 : parent_group->add_TD(td_cagroup);
254 : :
255 : : // add the attribOwnerEntity to the group and name the group
256 [ + - ]: 11 : parent_group->entity_name(group_name);
257 : : }
258 : :
259 : : // add the entity to the group with the proper sequence number
260 : 11 : TDCAGE::insert_entity(owned_entity, seq_num, parent_group);
261 : :
262 : 11 : return parent_group;
263 : : }
264 : :
265 : 0 : RefGroup *CAGroup::assign_ancestor_group(const int ancestor_id,
266 : : const int ancestor_uid,
267 : : const CubitString& ancestor_name,
268 : : const int owned_group_uid,
269 : : const int seq_num)
270 : : {
271 : : // for each call of this function, we:
272 : : // - get an ancestor group with ancestor_id, ancestor_uid and
273 : : // ancestor_name (make one if it doesn't exist)
274 : : // - add group with owned_group_uid to that ancestor group
275 : : // (owned_group_uid should exist, error if not)
276 : : // search for the group corresponding to this id and unique id
277 : 0 : RefGroup* ancestor_group = NULL;
278 : 0 : RefGroup *owned_group = NULL;
279 : 0 : CubitBoolean ancestor_id_exists = CUBIT_FALSE;
280 : :
281 : 0 : RefGroup *ref_group = GeometryQueryTool::instance()->get_last_ref_group();
282 : :
283 [ # # ][ # # ]: 0 : for(int i = GeometryQueryTool::instance()->num_ref_groups(); i > 0 &&
284 [ # # ]: 0 : (!ancestor_group || !owned_group); i--)
285 : : {
286 : 0 : ref_group = GeometryQueryTool::instance()->get_next_ref_group();
287 : :
288 [ # # ]: 0 : if(ref_group->id() == ancestor_id)
289 : : {
290 : 0 : ancestor_id_exists = CUBIT_TRUE;
291 : : }
292 : :
293 : 0 : ToolData *td_temp = ref_group->get_TD(&TDCAGE::is_cage);
294 [ # # ][ # # ]: 0 : TDCAGE *td_cagroup = (td_temp ? CAST_TO(td_temp, TDCAGE) : NULL);
295 [ # # ][ # # ]: 0 : if (td_cagroup != NULL && td_cagroup->unique_id() == ancestor_uid) {
[ # # ]
296 : 0 : ancestor_group = ref_group;
297 : : }
298 : :
299 [ # # ][ # # ]: 0 : if (td_cagroup != NULL && td_cagroup->unique_id() == owned_group_uid) {
[ # # ]
300 : 0 : owned_group = ref_group;
301 : : }
302 : : }
303 : :
304 [ # # ]: 0 : assert(owned_group != 0);
305 : :
306 [ # # ]: 0 : if (!ancestor_group)
307 : : {
308 : : // make a new group, and assign id and unique id
309 : : // also assign group name
310 : 0 : ancestor_group = RefEntityFactory::instance()->construct_RefGroup();
311 : : ;
312 [ # # ]: 0 : if(!ancestor_id_exists) {
313 : 0 : ancestor_group->set_id(0);
314 : 0 : ancestor_group->set_id(ancestor_id);
315 : : }
316 : : else
317 [ # # ]: 0 : PRINT_INFO("Creating group %d to hold attribute group %d\n",
318 [ # # ]: 0 : ancestor_group->id(), ancestor_id);
319 : :
320 : : // put a td on this new group with the right unique_id
321 [ # # ]: 0 : TDCAGE *td_cagroup = new TDCAGE(ancestor_uid);
322 : 0 : ancestor_group->add_TD(td_cagroup);
323 : :
324 : : // add the owned group to the group and name the group
325 [ # # ]: 0 : ancestor_group->entity_name(ancestor_name);
326 : : }
327 : :
328 : : // add the entity to the group with the proper sequence number
329 : 0 : TDCAGE::insert_entity(owned_group, seq_num, ancestor_group);
330 : :
331 : 0 : return ancestor_group;
332 : : }
333 : :
334 : 6356 : CubitStatus CAGroup::update()
335 : : {
336 [ - + ]: 6356 : if (hasUpdated) return CUBIT_SUCCESS;
337 : :
338 : : // set the updated flag
339 : 6356 : hasUpdated = CUBIT_TRUE;
340 : :
341 : : // get the groups containing attribOwnerEntity
342 : : RefGroup* ref_group;
343 [ + - ]: 6356 : DLIList<RefGroup*> ref_group_list;
344 : : int i;
345 : :
346 [ + - ]: 6356 : RefGroup::get_groups_within(attribOwnerEntity, ref_group_list, CUBIT_FALSE);
347 : :
348 [ + - ][ + + ]: 6356 : if( ref_group_list.size() == 0)
349 : : {
350 [ + - ]: 6345 : delete_attrib(CUBIT_TRUE);
351 : 6345 : return CUBIT_SUCCESS;
352 : : }
353 : :
354 : : // else, this entity is owned by groups
355 : : RefGroup* parent_ref_group;
356 : :
357 : : // get a td_cage onto the attribOwnerEntity, to keep sequence numbers
358 : : // for the owning groups
359 [ + - ]: 11 : TDCAGE *td_entity = (TDCAGE *) attribOwnerEntity->get_TD(&TDCAGE::is_cage);
360 [ + - ]: 11 : if (!td_entity) {
361 [ + - ][ + - ]: 11 : td_entity = new TDCAGE(-1);
362 [ + - ]: 11 : attribOwnerEntity->add_TD(td_entity);
363 : : }
364 : :
365 : : // now, initialize that tdcage
366 [ + - ]: 11 : td_entity->initialize_group_sequence_list(attribOwnerEntity);
367 : :
368 : : // ok, now write the data for the groups to this attribute
369 [ + - ][ + + ]: 22 : for(i = ref_group_list.size(); i > 0; i--)
370 : : {
371 : : // get the refgroup which gets assigned to this CAGroup
372 [ + - ]: 11 : ref_group = ref_group_list.get_and_step();
373 : :
374 : : // First, make sure there's a TDCAGE on the RefGroup
375 [ + - ]: 11 : ToolData *td_temp = ref_group->get_TD(&TDCAGE::is_cage);
376 [ - + ][ # # ]: 11 : TDCAGE *td_cagroup = (td_temp ? CAST_TO(td_temp, TDCAGE) : NULL);
377 [ + - ]: 11 : if (td_cagroup == NULL) {
378 : : #if defined _WIN32 || defined CUBIT_LINUX
379 [ + - ][ + - ]: 11 : td_cagroup = new TDCAGE(rand());
380 : : #else
381 : : td_cagroup = new TDCAGE((int)lrand48());
382 : : #endif
383 [ + - ]: 11 : ref_group->add_TD(td_cagroup);
384 [ + - ]: 11 : td_cagroup->initialize_group_sequence_list(ref_group);
385 : : }
386 : :
387 : : // append to this CAGroup the id and the unique id of the group;
388 : : // also append the group name
389 [ + - ][ + - ]: 11 : groupID.append(ref_group->id());
390 [ + - ][ + - ]: 11 : uniqueID.append(td_cagroup->unique_id());
391 [ + - ][ + - ]: 11 : groupNames.append(ref_group->entity_name());
[ + - ]
392 : :
393 : : // get and append the sequence number of the attribOwnerEntity
394 : : // in this group
395 [ + - ]: 11 : int seq_number = td_entity->td_sequence_number(ref_group);
396 [ - + ]: 11 : assert(seq_number != -1);
397 [ + - ]: 11 : sequenceNumbers.append(seq_number);
398 : :
399 : : // check this group for containing (parent) groups
400 [ + - ]: 11 : DLIList<RefGroup*> parent_ref_group_list;
401 [ + - ]: 11 : RefGroup::get_groups_within(ref_group, parent_ref_group_list, CUBIT_FALSE);
402 : :
403 : : // append the number of parent groups to the right list
404 [ + - ][ + - ]: 11 : numOwningGroups.append(parent_ref_group_list.size());
405 : :
406 : : // for each parent group, do essentially the same thing, adding the
407 : : // data to the owningGroup lists
408 [ + - ][ - + ]: 11 : for(int j = parent_ref_group_list.size(); j>0; j--)
409 : : {
410 [ # # ]: 0 : parent_ref_group = parent_ref_group_list.get_and_step();
411 [ # # ]: 0 : td_temp = parent_ref_group->get_TD(&TDCAGE::is_cage);
412 [ # # ][ # # ]: 0 : TDCAGE *td_parent = (td_temp ? CAST_TO(td_temp, TDCAGE) : NULL);
413 [ # # ]: 0 : if (td_parent == NULL) {
414 : : #if defined _WIN32 || defined CUBIT_LINUX
415 [ # # ][ # # ]: 0 : td_parent = new TDCAGE(rand());
416 : : #else
417 : : td_parent = new TDCAGE((int)lrand48());
418 : : #endif
419 [ # # ]: 0 : parent_ref_group->add_TD(td_parent);
420 [ # # ]: 0 : td_parent->initialize_group_sequence_list(parent_ref_group);
421 : : }
422 : :
423 : : // append to this CAGroup the id and the unique id of the group;
424 : : // also append the group name
425 [ # # ][ # # ]: 0 : owningGroupID.append(parent_ref_group->id());
426 [ # # ][ # # ]: 0 : owningUniqueID.append(td_parent->unique_id());
427 [ # # ][ # # ]: 0 : owningGroupNames.append(parent_ref_group->entity_name());
[ # # ]
428 : :
429 : : // get and append the sequence number of the group in the parent
430 : : // group
431 [ # # ]: 0 : seq_number = td_cagroup->td_sequence_number(parent_ref_group);
432 [ # # ]: 0 : assert(seq_number != -1);
433 [ # # ]: 0 : owningSequenceNumbers.append(seq_number);
434 : :
435 : : // finally, build a list of distant ancestors, in case there are
436 : : // groups more than twice removed from any real entities; make
437 : : // it a recursive function, so that it goes all the way up the chain
438 : : // of ancestors
439 [ # # ]: 0 : build_ancestor_list(parent_ref_group);
440 : :
441 : : } // loop over parent groups
442 [ + - ]: 11 : } // loop over groups containing attribOwnerEntity
443 : :
444 [ + - ]: 6356 : return CUBIT_SUCCESS;
445 : : }
446 : :
447 : 0 : CubitStatus CAGroup::reset()
448 : : {
449 : 0 : groupID.clean_out();
450 : : //- group ids containing attribOwnerEntity
451 : :
452 : 0 : uniqueID.clean_out();
453 : : //- unique ids of groups containing attribOwnerEntity
454 : :
455 : 0 : groupNames.clean_out();
456 : : //- names of groups containing attribOwnerEntity
457 : :
458 : 0 : sequenceNumbers.clean_out();
459 : : //- sequence numbers of this entity in the groups
460 : :
461 : 0 : numOwningGroups.clean_out();
462 : : //- for each group in groupID, number of groups owning those groups
463 : :
464 : 0 : owningGroupID.clean_out();
465 : : //- group ids containing groups containing attribOwnerEntity
466 : :
467 : 0 : owningUniqueID.clean_out();
468 : : //- unique ids of groups containing groups containing attribOwnerEntity
469 : :
470 : 0 : owningGroupNames.clean_out();
471 : : //- names of groups containing groups containing attribOwnerEntity
472 : :
473 : 0 : owningSequenceNumbers.clean_out();
474 : : //- sequence numbers of groups in owning groups
475 : :
476 : : //- for each ancestor (a group which owns only other groups, with those
477 : : //- those groups owning only other groups), we store the group id, uid,
478 : : //- name, and the uid of the owned group to which this is an ancestor
479 : 0 : ancestorGroupID.clean_out();
480 : 0 : ancestorUniqueID.clean_out();
481 : 0 : ancestorGroupName.clean_out();
482 : 0 : ancestorOwnedGroupUid.clean_out();
483 : 0 : ancestorSequenceNumbers.clean_out();
484 : :
485 : 0 : return CUBIT_SUCCESS;
486 : : }
487 : :
488 : 0 : void CAGroup::build_ancestor_list(RefGroup *parent_ref_group)
489 : : {
490 [ # # ]: 0 : DLIList<RefGroup*> ancestor_ref_group_list;
491 [ # # ]: 0 : RefGroup::get_groups_within(parent_ref_group, ancestor_ref_group_list, CUBIT_FALSE);
492 : :
493 : : // now, recursively work on ancestor list, adding owning group id,
494 : : // uid and name, and owned group uid, to lists
495 [ # # ]: 0 : ToolData *td_temp = parent_ref_group->get_TD(&TDCAGE::is_cage);
496 [ # # ][ # # ]: 0 : TDCAGE *td_parent = (td_temp ? CAST_TO(td_temp, TDCAGE) : NULL);
497 : :
498 [ # # ][ # # ]: 0 : for (int j = ancestor_ref_group_list.size(); j > 0; j--) {
499 [ # # ]: 0 : RefGroup *ancestor = ancestor_ref_group_list.get_and_step();
500 [ # # ]: 0 : td_temp = ancestor->get_TD(&TDCAGE::is_cage);
501 [ # # ][ # # ]: 0 : TDCAGE *td_cagroup = (td_temp ? CAST_TO(td_temp, TDCAGE) : NULL);
502 [ # # ]: 0 : if (td_cagroup == NULL) {
503 : : #if defined _WIN32 || defined CUBIT_LINUX
504 [ # # ][ # # ]: 0 : td_cagroup = new TDCAGE(rand());
505 : : #else
506 : : td_cagroup = new TDCAGE((int)lrand48());
507 : : #endif
508 [ # # ]: 0 : ancestor->add_TD(td_cagroup);
509 [ # # ]: 0 : td_cagroup->initialize_group_sequence_list(ancestor);
510 : : }
511 : :
512 [ # # ][ # # ]: 0 : ancestorGroupID.append(ancestor->id());
513 [ # # ][ # # ]: 0 : ancestorUniqueID.append(td_cagroup->unique_id());
514 [ # # ][ # # ]: 0 : ancestorGroupName.append(ancestor->entity_name());
[ # # ]
515 [ # # ][ # # ]: 0 : ancestorOwnedGroupUid.append(td_parent->unique_id());
516 : :
517 : : // get and append the sequence number of the group in the parent
518 : : // group
519 [ # # ]: 0 : int seq_number = td_parent->td_sequence_number(ancestor);
520 [ # # ]: 0 : assert(seq_number != -1);
521 [ # # ]: 0 : ancestorSequenceNumbers.append(seq_number);
522 : :
523 [ # # ]: 0 : build_ancestor_list(ancestor);
524 [ # # ]: 0 : }
525 : 0 : }
526 : :
527 : 6378 : CubitSimpleAttrib CAGroup::cubit_simple_attrib()
528 : : {
529 [ + - ]: 6378 : std::vector<CubitString> cs_list;
530 [ + - ][ + - ]: 12756 : std::vector<double> d_list;
531 [ + - ][ + - ]: 12756 : std::vector<int> i_list;
532 : :
533 : : // first, the ints
534 : : // groupID
535 [ + - ]: 6378 : groupID.reset();
536 [ + - ][ + - ]: 6378 : i_list.push_back(groupID.size());
537 : : int i;
538 [ + - ][ + + ]: 6411 : for (i = groupID.size(); i > 0; i--)
539 [ + - ][ + - ]: 33 : i_list.push_back(groupID.get_and_step());
540 : :
541 : : // uniqueID
542 [ + - ]: 6378 : uniqueID.reset();
543 [ + - ][ + + ]: 6411 : for (i = uniqueID.size(); i > 0; i--)
544 [ + - ][ + - ]: 33 : i_list.push_back(uniqueID.get_and_step());
545 : :
546 : : // sequenceNumbers
547 [ + - ]: 6378 : sequenceNumbers.reset();
548 [ + - ][ + + ]: 6411 : for (i = sequenceNumbers.size(); i > 0; i--)
549 [ + - ][ + - ]: 33 : i_list.push_back(sequenceNumbers.get_and_step());
550 : :
551 : : // numOwningGroups
552 [ + - ]: 6378 : numOwningGroups.reset();
553 [ + - ][ + + ]: 6411 : for (i = numOwningGroups.size(); i > 0; i--)
554 [ + - ][ + - ]: 33 : i_list.push_back(numOwningGroups.get_and_step());
555 : :
556 : : // size of owningGroupID
557 [ + - ][ + - ]: 6378 : i_list.push_back(owningGroupID.size());
558 : :
559 : : // owningGroupID
560 [ + - ]: 6378 : owningGroupID.reset();
561 [ + - ][ - + ]: 6378 : for (i = owningGroupID.size(); i > 0; i--)
562 [ # # ][ # # ]: 0 : i_list.push_back(owningGroupID.get_and_step());
563 : :
564 : : // owningUniqueID
565 [ + - ]: 6378 : owningUniqueID.reset();
566 [ + - ][ - + ]: 6378 : for (i = owningUniqueID.size(); i > 0; i--)
567 [ # # ][ # # ]: 0 : i_list.push_back(owningUniqueID.get_and_step());
568 : :
569 : : // owningSequenceNumbers
570 [ + - ]: 6378 : owningSequenceNumbers.reset();
571 [ + - ][ - + ]: 6378 : for (i = owningSequenceNumbers.size(); i > 0; i--)
572 [ # # ][ # # ]: 0 : i_list.push_back(owningSequenceNumbers.get_and_step());
573 : :
574 : : // size of ancestorGroupID
575 [ + - ][ + - ]: 6378 : i_list.push_back(ancestorGroupID.size());
576 : :
577 : : // ancestorGroupID
578 [ + - ]: 6378 : ancestorGroupID.reset();
579 [ + - ][ - + ]: 6378 : for (i = ancestorGroupID.size(); i > 0; i--)
580 [ # # ][ # # ]: 0 : i_list.push_back(ancestorGroupID.get_and_step());
581 : :
582 : : // ancestorUniqueID
583 [ + - ]: 6378 : ancestorUniqueID.reset();
584 [ + - ][ - + ]: 6378 : for (i = ancestorUniqueID.size(); i > 0; i--)
585 [ # # ][ # # ]: 0 : i_list.push_back(ancestorUniqueID.get_and_step());
586 : :
587 : : // ancestorOwnedGroupUid
588 [ + - ]: 6378 : ancestorOwnedGroupUid.reset();
589 [ + - ][ - + ]: 6378 : for (i = ancestorOwnedGroupUid.size(); i > 0; i--)
590 [ # # ][ # # ]: 0 : i_list.push_back(ancestorOwnedGroupUid.get_and_step());
591 : :
592 : : // ancestorSequenceNumbers
593 [ + - ]: 6378 : ancestorSequenceNumbers.reset();
594 [ + - ][ - + ]: 6378 : for (i = ancestorSequenceNumbers.size(); i > 0; i--)
595 [ # # ][ # # ]: 0 : i_list.push_back(ancestorSequenceNumbers.get_and_step());
596 : :
597 : : // now, doubles (none)
598 : :
599 : : // now, strings
600 : : // attribute internal name
601 [ + - ][ + - ]: 6378 : cs_list.push_back(att_internal_name());
[ + - ][ + - ]
602 : :
603 : : // groupNames
604 [ + - ]: 6378 : groupNames.reset();
605 [ + - ][ + + ]: 6411 : for (i = groupID.size(); i > 0; i--)
606 [ + - ][ + - ]: 33 : cs_list.push_back(groupNames.get_and_step());
607 : :
608 : : // owningGroupNames
609 [ + - ]: 6378 : owningGroupNames.reset();
610 [ + - ][ - + ]: 6378 : for (i = owningGroupNames.size(); i > 0; i--)
611 [ # # ][ # # ]: 0 : cs_list.push_back(owningGroupNames.get_and_step());
612 : :
613 : : // ancestorGroupName
614 [ + - ]: 6378 : ancestorGroupName.reset();
615 [ + - ][ - + ]: 6378 : for (i = ancestorGroupName.size(); i > 0; i--)
616 [ # # ][ # # ]: 0 : cs_list.push_back(ancestorGroupName.get_and_step());
617 : :
618 [ + - ][ + - ]: 12756 : return CubitSimpleAttrib(&cs_list, &d_list, &i_list);
619 : : }
620 : :
621 : 6367 : void CAGroup::has_written(CubitBoolean has_written)
622 : : {
623 : : //- overloaded has_written function, resets td_cage on owner
624 [ + + ][ + - ]: 6367 : if (has_written == CUBIT_TRUE && hasWritten == CUBIT_FALSE)
625 : : // reset the td_cage on the owner
626 : 11 : attribOwnerEntity->delete_TD(&TDCAGE::is_cage);
627 : :
628 : 6367 : hasWritten = has_written;
629 [ + - ][ + - ]: 6540 : }
|
