Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : GroupingEntity.cpp
3 : : //
4 : : // Purpose : This file contains the implementation of the class
5 : : // GroupingEntity.
6 : : //
7 : : // Special Notes :
8 : : //
9 : : // Creator : Xuechen Liu
10 : : //
11 : : // Creation Date : 07/11/96
12 : : //
13 : : // Owner : Malcolm J. Panthaki
14 : : //-------------------------------------------------------------------------
15 : :
16 : : // ********** BEGIN STANDARD INCLUDES **********
17 : : // ********** END STANDARD INCLUDES **********
18 : :
19 : : // ********** BEGIN CUBIT INCLUDES **********
20 : : #include "GroupingEntity.hpp"
21 : : #include "SenseEntity.hpp"
22 : : #include "BasicTopologyEntity.hpp"
23 : :
24 : : #include "DLIList.hpp"
25 : : #include "ModelQueryEngine.hpp"
26 : :
27 : : // ********** END CUBIT INCLUDES **********
28 : :
29 : :
30 : : // ********** BEGIN STATIC DECLARATIONS **********
31 : : // ********** END STATIC DECLARATIONS **********
32 : :
33 : : // ********** BEGIN PUBLIC FUNCTIONS **********
34 : :
35 : : //-------------------------------------------------------------------------
36 : : // Purpose : The destructor
37 : : //
38 : : // Special Notes :
39 : : //
40 : : // Creator : Malcolm J. Panthaki
41 : : //
42 : : // Creation Date : 09/03/96
43 : : //-------------------------------------------------------------------------
44 : 71478 : GroupingEntity::~GroupingEntity()
45 : : {
46 [ - + ]: 35739 : if (myParent)
47 [ # # ]: 0 : myParent->remove_grouping_entity(this);
48 [ - + ][ # # ]: 35739 : while (firstSenseEntity && remove_sense_entity(firstSenseEntity));
[ # # ][ - + ]
49 : :
50 [ + - ][ + - ]: 35739 : assert (!myParent && !nextInParent && !firstSenseEntity);
[ - + ]
51 [ - + ]: 35739 : }
52 : :
53 : : //-------------------------------------------------------------------------
54 : : // Purpose : This function returns a list of SenseEntity
55 : : // pointers associated with this grouping entity.
56 : : //
57 : : // Special Notes : Complete reimplementation - j.k. July 2003
58 : : //
59 : : // Creator : Xuechen Liu
60 : : //
61 : : // Creation Date : 07/28/96
62 : : //-------------------------------------------------------------------------
63 : 7164 : CubitStatus GroupingEntity::get_sense_entity_list( DLIList<SenseEntity*>& list)
64 : : {
65 [ - + ]: 7164 : if (!firstSenseEntity)
66 : 0 : return CUBIT_SUCCESS;
67 : :
68 [ + - ][ + + ]: 32652 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next())
69 : : {
70 [ + - ][ - + ]: 25488 : assert(ptr->get_grouping_entity_ptr() == this);
71 [ + - ]: 25488 : list.append(ptr);
72 : : }
73 : 7164 : return CUBIT_SUCCESS;
74 : : }
75 : :
76 : : //-------------------------------------------------------------------------
77 : : // Purpose : This function adds a sense entity to the list of
78 : : // sense entities of a grouping entity.
79 : : //
80 : : // Special Notes : In the DAG, the sense entities associated with the
81 : : // current grouping entity are linked from one sense
82 : : // entity to another in order to maintain the order in
83 : : // which the sense entities were added to the grouping
84 : : // entity.
85 : : //
86 : : // Complete reimplementation - j.k. July 2003
87 : : //
88 : : // Creator : Malcolm J. Panthaki
89 : : //
90 : : // Creation Date : 07/31/96
91 : : //-------------------------------------------------------------------------
92 : 70502 : CubitStatus GroupingEntity::add_sense_entity(SenseEntity *sense_entity,
93 : : SenseEntity *after_this)
94 : : {
95 : : // Check to make sure that we are getting the correct type of
96 : : // SenseEntity.
97 [ + - ][ + - ]: 70502 : if ( dag_type() != sense_entity->dag_type().parent() )
[ + - ][ - + ]
98 : 0 : return CUBIT_FAILURE ;
99 : :
100 : : // Check that the sense entity is not already in some other
101 : : // grouping entity
102 [ - + ]: 70502 : if ( sense_entity->get_grouping_entity_ptr() )
103 : 0 : return CUBIT_FAILURE;
104 : :
105 : : // prev and next ptrs should be NULL if sense entity is not
106 : : // in a grouping entity
107 [ + - ][ - + ]: 70502 : assert (!sense_entity->next() && !sense_entity->previous());
108 : :
109 [ + + ]: 70502 : if (after_this)
110 : : {
111 [ - + ]: 35251 : if (after_this->get_grouping_entity_ptr() != this )
112 : 0 : return CUBIT_FAILURE;
113 : :
114 [ - + ]: 35251 : if (!sense_entity->gpe_insert_after(after_this))
115 : 0 : return CUBIT_FAILURE;
116 : :
117 [ + - ]: 35251 : if (after_this == lastSenseEntity)
118 : 35251 : lastSenseEntity = sense_entity;
119 : : }
120 [ - + ]: 35251 : else if (lastSenseEntity)
121 : : {
122 [ # # ]: 0 : if (!sense_entity->gpe_insert_after(lastSenseEntity))
123 : 0 : return CUBIT_FAILURE;
124 : 0 : lastSenseEntity = sense_entity;
125 : : }
126 : : else
127 : : {
128 : 35251 : firstSenseEntity = lastSenseEntity = sense_entity;
129 : : }
130 : :
131 : 70502 : sense_entity->set_grouping_entity_ptr(this);
132 : 70502 : return CUBIT_SUCCESS;
133 : : }
134 : :
135 : :
136 : : //-------------------------------------------------------------------------
137 : : // Purpose : Remove a child sense entity
138 : : //
139 : : // Special Notes :
140 : : //
141 : : // Creator : Jason Kraftcheck
142 : : //
143 : : // Creation Date : 07/22/03
144 : : //-------------------------------------------------------------------------
145 : 97936 : CubitStatus GroupingEntity::remove_sense_entity( SenseEntity* sense_entity_ptr )
146 : : {
147 [ - + ]: 97936 : if (sense_entity_ptr->get_grouping_entity_ptr() != this)
148 : 0 : return CUBIT_FAILURE;
149 : :
150 [ + + ]: 97936 : if (firstSenseEntity == sense_entity_ptr)
151 : 96547 : firstSenseEntity = sense_entity_ptr->next();
152 [ + + ]: 97936 : if (lastSenseEntity == sense_entity_ptr)
153 : 36472 : lastSenseEntity = sense_entity_ptr->previous();
154 : :
155 : 97936 : sense_entity_ptr->gpe_remove();
156 : 97936 : sense_entity_ptr->set_grouping_entity_ptr(NULL);
157 : 97936 : return CUBIT_SUCCESS;
158 : : }
159 : :
160 : : //-------------------------------------------------------------------------
161 : : // Purpose : Change/update/re-order child SenseEntity list
162 : : //
163 : : // Special Notes :
164 : : //
165 : : // Creator : Jason Kraftcheck
166 : : //
167 : : // Creation Date : 11/03/03
168 : : //-------------------------------------------------------------------------
169 : 26518 : CubitStatus GroupingEntity::set_sense_entity_list(
170 : : DLIList<SenseEntity*>& list,
171 : : DLIList<SenseEntity*>& removed )
172 : : {
173 : : int i;
174 : :
175 : : // Remove all?
176 [ - + ]: 26518 : if (list.size() == 0)
177 : : {
178 : 0 : get_sense_entity_list( removed );
179 : 0 : return disconnect_all_children();
180 : : }
181 : :
182 : : // Check for error conditions before modifying anything
183 : 26518 : list.reset();
184 [ + + ]: 125813 : for (i = list.size(); i--; )
185 : : {
186 : 99295 : SenseEntity* sense_entity = list.get_and_step();
187 : :
188 : : // Check to make sure that we are getting the correct type of
189 : : // SenseEntity.
190 [ + - ][ + - ]: 99295 : if ( dag_type() != sense_entity->dag_type().parent() )
[ + - ][ - + ]
191 : 0 : return CUBIT_FAILURE ;
192 : :
193 : : // Check that the sense entity is not already in some other
194 : : // grouping entity
195 [ + + - + ]: 110780 : if ( sense_entity->get_grouping_entity_ptr() &&
[ - + ]
196 : 11485 : sense_entity->get_grouping_entity_ptr() != this )
197 : 0 : return CUBIT_FAILURE;
198 : : }
199 : :
200 : : // Special case for first entity in list.
201 : 26518 : list.reset();
202 : 26518 : SenseEntity* new_first = list.get_and_step();
203 : : // No sense entities currently attached...
204 [ + + ]: 26518 : if (!firstSenseEntity)
205 : : {
206 : 22964 : firstSenseEntity = lastSenseEntity = new_first;
207 : 22964 : new_first->set_grouping_entity_ptr(this);
208 : : }
209 : : // Already attached, but not first in list...
210 [ + + ]: 3554 : else if( firstSenseEntity != new_first )
211 : : {
212 [ + + ]: 438 : if (!new_first->get_grouping_entity_ptr())
213 : 297 : new_first->set_grouping_entity_ptr(this);
214 : : else
215 : : {
216 [ + + ]: 141 : if (lastSenseEntity == new_first)
217 : 75 : lastSenseEntity = new_first->previous();
218 : 141 : new_first->gpe_remove();
219 : : }
220 : :
221 : 438 : new_first->gpe_insert_before(firstSenseEntity);
222 : 438 : firstSenseEntity = new_first;
223 : : }
224 : :
225 : : // Now loop through remaining sense entities.
226 : 26518 : SenseEntity* prev = new_first;
227 [ + + ]: 99295 : for (i = list.size() - 1; i--; )
228 : : {
229 : 72777 : SenseEntity* curr = list.get_and_step();
230 : :
231 : : // If next sense entity in input list is not
232 : : // next sense entity in this GroupingEntity...
233 [ + + ]: 72777 : if (prev->next() != curr)
234 : : {
235 [ + + ]: 65586 : if (!curr->get_grouping_entity_ptr())
236 : 64549 : curr->set_grouping_entity_ptr(this);
237 : : else
238 : : {
239 [ + + ]: 1037 : if (lastSenseEntity == curr)
240 : 370 : lastSenseEntity = curr->previous();
241 : 1037 : curr->gpe_remove();
242 : : }
243 : 65586 : curr->gpe_insert_after(prev);
244 : : }
245 : :
246 : : // update lastSenseEntity if necessary...
247 [ + + ]: 72777 : if (lastSenseEntity == prev)
248 : 63064 : lastSenseEntity = curr;
249 : :
250 : : // iterate
251 : 72777 : prev = curr;
252 : : }
253 : :
254 : : // Disconnect any sense entities in this GroupingEntity
255 : : // that were not in in the input list (they should now
256 : : // be at the end of the list of sense entities in this)
257 : : // and pass them back in the 'removed' list.
258 : 26518 : CubitStatus result = CUBIT_SUCCESS;
259 [ + + ]: 27706 : while (prev != lastSenseEntity)
260 : : {
261 [ + - ]: 1188 : removed.append(prev->next());
262 [ - + ]: 1188 : if (!remove_sense_entity(prev->next()))
263 : : {
264 : 0 : assert(0);
265 : : result = CUBIT_FAILURE;
266 : : prev = prev->next();
267 : : }
268 : : }
269 : :
270 : 26518 : return result;
271 : : }
272 : :
273 : :
274 : : //-------------------------------------------------------------------------
275 : : // Purpose : Invert
276 : : //
277 : : // Special Notes :
278 : : //
279 : : // Creator : Jason Kraftcheck
280 : : //
281 : : // Creation Date : 07/22/03
282 : : //-------------------------------------------------------------------------
283 : 0 : void GroupingEntity::reverse_direction()
284 : : {
285 : : SenseEntity* ptr;
286 [ # # ]: 0 : if (!firstSenseEntity)
287 : 0 : return;
288 : :
289 : : // For each child sense entity
290 [ # # ]: 0 : for (ptr = firstSenseEntity; ptr; ptr = ptr->previous())
291 : : {
292 : : // change linked list pointers
293 : 0 : ptr->swap_gpe_list_ptrs();
294 : : // change sense
295 : 0 : ptr->reverse_sense();
296 : : }
297 : :
298 : : // Change first pointer the old last entity
299 : : // (Preserves order as returnd by old DLIList rep and
300 : : // makes this work to reverse a chain.)
301 : 0 : ptr = firstSenseEntity;
302 : 0 : firstSenseEntity = lastSenseEntity;
303 : 0 : lastSenseEntity = ptr;
304 : : }
305 : :
306 : : //-------------------------------------------------------------------------
307 : : // Purpose : Get parent basic topology entity.
308 : : //
309 : : // Special Notes :
310 : : //
311 : : // Creator : Jason Kraftcheck
312 : : //
313 : : // Creation Date : 07/22/03
314 : : //-------------------------------------------------------------------------
315 : 35229 : int GroupingEntity::get_parents( DLIList<TopologyEntity*>* list ) const
316 : : {
317 [ + - ]: 35229 : if (!myParent)
318 : 35229 : return 0;
319 : :
320 [ # # ]: 0 : if (list)
321 [ # # ]: 0 : list->append(myParent);
322 : :
323 : 35229 : return 1;
324 : : }
325 : :
326 : : //-------------------------------------------------------------------------
327 : : // Purpose : Get child sense entities
328 : : //
329 : : // Special Notes :
330 : : //
331 : : // Creator : Jason Kraftcheck
332 : : //
333 : : // Creation Date : 07/22/03
334 : : //-------------------------------------------------------------------------
335 : 510 : int GroupingEntity::get_children( DLIList<TopologyEntity*>* list ) const
336 : : {
337 [ + - ]: 510 : if (!firstSenseEntity)
338 : 510 : return 0;
339 : :
340 : 0 : int count = 0;
341 [ # # ]: 0 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next() )
342 : : {
343 [ # # ]: 0 : assert(ptr->get_grouping_entity_ptr() == this);
344 [ # # ]: 0 : if(list)
345 [ # # ]: 0 : list->append(ptr);
346 : 0 : count++;
347 : : }
348 : :
349 : 510 : return count;
350 : : }
351 : :
352 : : // ********** END PUBLIC FUNCTIONS **********
353 : :
354 : : // ********** BEGIN PROTECTED FUNCTIONS **********
355 : :
356 : : //-------------------------------------------------------------------------
357 : : // Purpose : Remove a child sense entity
358 : : //
359 : : // Special Notes :
360 : : //
361 : : // Creator : Jason Kraftcheck
362 : : //
363 : : // Creation Date : 07/22/03
364 : : //-------------------------------------------------------------------------
365 : 0 : CubitStatus GroupingEntity::remove_child_link( TopologyEntity* child_ptr )
366 : : {
367 [ # # ]: 0 : SenseEntity* se = dynamic_cast<SenseEntity*>(child_ptr);
368 [ # # ]: 0 : if (!se)
369 : 0 : return CUBIT_FAILURE;
370 : :
371 : 0 : return remove_sense_entity(se);
372 : : }
373 : :
374 : : //-------------------------------------------------------------------------
375 : : // Purpose : Remove from all parent BasicTopologyEntities
376 : : //
377 : : // Special Notes :
378 : : //
379 : : // Creator : Jason Kraftcheck
380 : : //
381 : : // Creation Date : 07/22/03
382 : : //-------------------------------------------------------------------------
383 : 0 : CubitStatus GroupingEntity::disconnect_all_parents( DLIList<TopologyEntity*>* list )
384 : : {
385 [ # # ]: 0 : if (!myParent)
386 : 0 : return CUBIT_SUCCESS;
387 [ # # ]: 0 : if (list)
388 [ # # ]: 0 : list->append(myParent);
389 : 0 : return myParent->remove_grouping_entity(this);
390 : : }
391 : :
392 : : //-------------------------------------------------------------------------
393 : : // Purpose : Remove all child SenseEntitys
394 : : //
395 : : // Special Notes :
396 : : //
397 : : // Creator : Jason Kraftcheck
398 : : //
399 : : // Creation Date : 07/22/03
400 : : //-------------------------------------------------------------------------
401 : 35229 : CubitStatus GroupingEntity::disconnect_all_children( DLIList<TopologyEntity*>* list)
402 : : {
403 [ + + ]: 130729 : while (firstSenseEntity)
404 : : {
405 [ + - ]: 95500 : if (list)
406 [ + - ]: 95500 : list->append(firstSenseEntity);
407 [ - + ]: 95500 : if (!remove_sense_entity(firstSenseEntity))
408 : 0 : return CUBIT_FAILURE;
409 : : }
410 : 35229 : return CUBIT_SUCCESS;
411 : : }
412 : :
413 : : //-------------------------------------------------------------------------
414 : : // Purpose : Functions to support ModelQueryEngine
415 : : //
416 : : // Special Notes :
417 : : //
418 : : // Creator : Jason Kraftcheck
419 : : //
420 : : // Creation Date : 07/24/03
421 : : //-------------------------------------------------------------------------
422 : 133561 : CubitBoolean GroupingEntity::query_append_parents( DLIList<TopologyEntity*>& list )
423 : : {
424 [ + - ][ + + ]: 133561 : if (myParent && !ModelQueryEngine::instance()->encountered(myParent))
[ + + ]
425 : : {
426 [ + - ]: 130981 : list.append(myParent);
427 : 130981 : return CUBIT_TRUE;
428 : : }
429 : :
430 : 133561 : return CUBIT_FALSE;
431 : : }
432 : 651511 : CubitBoolean GroupingEntity::query_append_children( DLIList<TopologyEntity*>& list )
433 : : {
434 : 651511 : ModelQueryEngine *const mqe = ModelQueryEngine::instance();
435 : 651511 : CubitBoolean found_some = CUBIT_FALSE;
436 : :
437 [ + + ]: 651511 : if (!firstSenseEntity)
438 : 35251 : return CUBIT_FALSE;
439 : :
440 [ + + ]: 2355175 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next())
441 : : {
442 [ + - ]: 1738915 : if (!mqe->encountered(ptr))
443 : : {
444 [ + - ]: 1738915 : list.append(ptr);
445 : 1738915 : found_some = CUBIT_TRUE;
446 : : }
447 : : }
448 : :
449 : 651511 : return found_some;
450 [ + - ][ + - ]: 6540 : }
|
