Branch data Line data Source code
1 : : ///-------------------------------------------------------------------------
2 : : // Filename : BasicTopologyEntity.cpp
3 : : //
4 : : // Purpose : This file contains the implementation of the class
5 : : // BasicTopologyEntity.
6 : : //
7 : : // Special Notes :
8 : : //
9 : : // Creator : Malcolm J. Panthaki
10 : : //
11 : : // Creation Date : 10/15/96
12 : : //
13 : : // Owner : Malcolm J. Panthaki
14 : : //-------------------------------------------------------------------------
15 : :
16 : : // ********** BEGIN STANDARD INCLUDES **********
17 : : // ********** END STANDARD INCLUDES **********
18 : :
19 : : // ********** BEGIN CUBIT INCLUDES **********
20 : : #include "CubitDefines.h"
21 : : #include "SenseEntity.hpp"
22 : : #include "BasicTopologyEntity.hpp"
23 : : #include "GroupingEntity.hpp"
24 : : #include "GeometryEntity.hpp"
25 : : #include "DLIList.hpp"
26 : : #include "ModelQueryEngine.hpp"
27 : : // ********** END CUBIT INCLUDES **********
28 : :
29 : : // ********** BEGIN STATIC DECLARATIONS **********
30 : : // ********** END STATIC DECLARATIONS **********
31 : :
32 : : // ********** BEGIN PUBLIC FUNCTIONS **********
33 : :
34 : : //-------------------------------------------------------------------------
35 : : // Purpose : destructor
36 : : //
37 : : // Special Notes :
38 : : //
39 : : // Creator : Jason Kraftcheck
40 : : //
41 : : // Creation Date : 07/22/03
42 : : //-------------------------------------------------------------------------
43 [ + - ]: 97370 : BasicTopologyEntity::~BasicTopologyEntity()
44 : : {
45 [ - + ][ # # ]: 48685 : while (firstSenseEntity && remove_sense_entity(firstSenseEntity));
[ # # ][ - + ]
46 [ - + ][ # # ]: 48685 : while (firstGroupingEntity && remove_grouping_entity(firstGroupingEntity));
[ # # ][ - + ]
47 [ + - ][ - + ]: 48685 : assert(!firstSenseEntity && !firstGroupingEntity);
48 [ - + ]: 48685 : }
49 : :
50 : :
51 : : //-------------------------------------------------------------------------
52 : : // Purpose : This function gets the list of GroupingEntities of this
53 : : // BasicTopologyEntity.
54 : : //
55 : : // Special Notes : In the DAG, the GroupingEntities associated with the
56 : : // current BasicTopologyEntity are linked from one GroupingEntity
57 : : // to the next in order to maintain the order in
58 : : // which the GroupingEntities were added to the BTE.
59 : : //
60 : : // Complete reimplementation - jk, July 2003
61 : : //
62 : : // Creator : Malcolm J. Panthaki
63 : : //
64 : : // Creation Date : 07/31/96
65 : : //-------------------------------------------------------------------------
66 : 1835 : CubitStatus BasicTopologyEntity::get_grouping_entity_list(
67 : : DLIList<GroupingEntity*>& list) const
68 : : {
69 [ + - ][ + + ]: 2987 : for (GroupingEntity* ptr = firstGroupingEntity; ptr; ptr = ptr->next())
70 : : {
71 [ + - ][ - + ]: 1152 : assert(ptr->get_basic_topology_entity_ptr() == this);
72 [ + - ]: 1152 : list.append(ptr);
73 : : }
74 : :
75 : 1835 : return CUBIT_SUCCESS;
76 : : }
77 : :
78 : : //-------------------------------------------------------------------------
79 : : // Purpose : Get the parent SenseEntities
80 : : //
81 : : // Special Notes :
82 : : //
83 : : // Creator : Jason Kraftcheck
84 : : //
85 : : // Creation Date : 06/08/99
86 : : //-------------------------------------------------------------------------
87 : 0 : CubitStatus BasicTopologyEntity::get_sense_entity_list(
88 : : DLIList<SenseEntity*>& list) const
89 : : {
90 [ # # ][ # # ]: 0 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
91 : : {
92 [ # # ][ # # ]: 0 : assert(ptr->get_basic_topology_entity_ptr() == this);
93 [ # # ]: 0 : list.append(ptr);
94 : : }
95 : 0 : return CUBIT_SUCCESS;
96 : : }
97 : :
98 : : //-------------------------------------------------------------------------
99 : : // Purpose : Attach a child grouping entity
100 : : //
101 : : // Special Notes :
102 : : //
103 : : // Creator : Jason Kraftcheck
104 : : //
105 : : // Creation Date : 07/22/03
106 : : //-------------------------------------------------------------------------
107 : 35251 : CubitStatus BasicTopologyEntity::add_grouping_entity( GroupingEntity* gpe_ptr)
108 : : {
109 [ + - ][ + - ]: 35251 : if (gpe_ptr->dag_type().parent() != dag_type())
[ - + ]
110 : 0 : return CUBIT_FAILURE;
111 : :
112 [ - + ]: 35251 : if (gpe_ptr->get_basic_topology_entity_ptr())
113 : 0 : return CUBIT_FAILURE;
114 : :
115 [ - + ]: 35251 : assert(!gpe_ptr->next());
116 : :
117 [ - + ]: 35251 : if (firstGroupingEntity)
118 : : {
119 [ # # ]: 0 : if (!gpe_ptr->insert_after(lastGroupingEntity))
120 : 0 : return CUBIT_FAILURE;
121 : : }
122 : : else
123 : : {
124 : 35251 : firstGroupingEntity = gpe_ptr;
125 : : }
126 : :
127 : 35251 : lastGroupingEntity = gpe_ptr;
128 : 35251 : gpe_ptr->set_basic_topology_entity_ptr(this);
129 : 35251 : return CUBIT_SUCCESS;
130 : : }
131 : :
132 : : //-------------------------------------------------------------------------
133 : : // Purpose : Disconnect child grouping entity
134 : : //
135 : : // Special Notes :
136 : : //
137 : : // Creator : Jason Kraftcheck
138 : : //
139 : : // Creation Date : 07/22/03
140 : : //-------------------------------------------------------------------------
141 : 34190 : CubitStatus BasicTopologyEntity::remove_grouping_entity( GroupingEntity* gpe_ptr)
142 : : {
143 [ - + ]: 34190 : if (gpe_ptr->get_basic_topology_entity_ptr() != this)
144 : 0 : return CUBIT_FAILURE;
145 : :
146 : 34190 : GroupingEntity* next_gpe_ptr = gpe_ptr->next();
147 : 34190 : GroupingEntity* prev_gpe_ptr = gpe_ptr->previous();
148 : :
149 [ - + ]: 34190 : if (!gpe_ptr->remove_from_list())
150 : 0 : return CUBIT_FAILURE;
151 : :
152 [ + + ]: 34190 : if (firstGroupingEntity == gpe_ptr)
153 : 33963 : firstGroupingEntity = next_gpe_ptr;
154 [ + + ]: 34190 : if (lastGroupingEntity == gpe_ptr)
155 : 33645 : lastGroupingEntity = prev_gpe_ptr;
156 : :
157 : 34190 : gpe_ptr->set_basic_topology_entity_ptr(0);
158 : 34190 : return CUBIT_SUCCESS;
159 : : }
160 : :
161 : : //-------------------------------------------------------------------------
162 : : // Purpose : Update list of child grouping entities
163 : : //
164 : : // Special Notes :
165 : : //
166 : : // Creator : Jason Kraftcheck
167 : : //
168 : : // Creation Date : 12/12/03
169 : : //-------------------------------------------------------------------------
170 : 22212 : CubitStatus BasicTopologyEntity::set_grouping_entity_list(
171 : : DLIList<GroupingEntity*>& list,
172 : : DLIList<GroupingEntity*>& removed )
173 : : {
174 : : int i;
175 : :
176 : : // Remove all?
177 [ + + ]: 22212 : if (list.size() == 0)
178 : : {
179 : 11 : get_grouping_entity_list( removed );
180 : 11 : return disconnect_all_children();
181 : : }
182 : :
183 : : // Check for error conditions before modifying anything
184 : 22201 : list.reset();
185 [ + + ]: 45630 : for (i = list.size(); i--; )
186 : : {
187 : 23429 : GroupingEntity* grouping_entity = list.get_and_step();
188 : :
189 : : // Check to make sure that we are getting the correct type of
190 : : // GroupingEntity.
191 [ + - ][ + - ]: 23429 : if ( dag_type() != grouping_entity->dag_type().parent() )
[ + - ][ - + ]
192 : 0 : return CUBIT_FAILURE ;
193 : :
194 : : // Check that the grouping entity is not already in some other
195 : : // basic topology entity
196 [ + + - + ]: 26610 : if ( grouping_entity->get_basic_topology_entity_ptr() &&
[ - + ]
197 : 3181 : grouping_entity->get_basic_topology_entity_ptr() != this )
198 : 0 : return CUBIT_FAILURE;
199 : : }
200 : :
201 : : // Special case for first entity in list.
202 : 22201 : list.reset();
203 : 22201 : GroupingEntity* new_first = list.get_and_step();
204 : : // No sense entities currently attached...
205 [ + + ]: 22201 : if (!firstGroupingEntity)
206 : : {
207 : 18881 : firstGroupingEntity = lastGroupingEntity = new_first;
208 : 18881 : new_first->set_basic_topology_entity_ptr(this);
209 : : }
210 : : // Already attached, but not first in list...
211 [ + + ]: 3320 : else if( firstGroupingEntity != new_first )
212 : : {
213 [ + - ]: 183 : if (!new_first->get_basic_topology_entity_ptr())
214 : 183 : new_first->set_basic_topology_entity_ptr(this);
215 : : else
216 : : {
217 [ # # ]: 0 : if (lastGroupingEntity == new_first)
218 : 0 : lastGroupingEntity = new_first->previous();
219 : 0 : new_first->remove_from_list();
220 : : }
221 : :
222 : 183 : new_first->insert_before(firstGroupingEntity);
223 : 183 : firstGroupingEntity = new_first;
224 : : }
225 : :
226 : : // Now loop through remaining sense entities.
227 : 22201 : GroupingEntity* prev = new_first;
228 [ + + ]: 23429 : for (i = list.size() - 1; i--; )
229 : : {
230 : 1228 : GroupingEntity* curr = list.get_and_step();
231 : :
232 : : // If next grouping entity in input list is not
233 : : // next grouping entity in this BTE...
234 [ + + ]: 1228 : if (prev->next() != curr)
235 : : {
236 [ + - ]: 1184 : if (!curr->get_basic_topology_entity_ptr())
237 : 1184 : curr->set_basic_topology_entity_ptr(this);
238 : : else
239 : : {
240 [ # # ]: 0 : if (lastGroupingEntity == curr)
241 : 0 : lastGroupingEntity = curr->previous();
242 : 0 : curr->remove_from_list();
243 : : }
244 : 1184 : curr->insert_after(prev);
245 : : }
246 : :
247 : : // update lastSenseEntity if necessary...
248 [ + + ]: 1228 : if (lastGroupingEntity == prev)
249 : 992 : lastGroupingEntity = curr;
250 : :
251 : : // iterate
252 : 1228 : prev = curr;
253 : : }
254 : :
255 : : // Disconnect any grouping entities in this BTE
256 : : // that were not in in the input list (they should now
257 : : // be at the end of the list of grouping entities in this)
258 : : // and pass them back in the 'removed' list.
259 : 22201 : CubitStatus result = CUBIT_SUCCESS;
260 [ + + ]: 22428 : while (prev != lastGroupingEntity)
261 : : {
262 [ + - ]: 227 : removed.append(prev->next());
263 [ - + ]: 227 : if (!remove_grouping_entity(prev->next()))
264 : : {
265 : 0 : assert(0);
266 : : result = CUBIT_FAILURE;
267 : : prev = prev->next();
268 : : }
269 : : }
270 : :
271 : 22212 : return result;
272 : : }
273 : :
274 : :
275 : :
276 : :
277 : : //-------------------------------------------------------------------------
278 : : // Purpose : Attach a parent sense entity
279 : : //
280 : : // Special Notes :
281 : : //
282 : : // Creator : Jason Kraftcheck
283 : : //
284 : : // Creation Date : 07/22/03
285 : : //-------------------------------------------------------------------------
286 : 160776 : CubitStatus BasicTopologyEntity::add_sense_entity( SenseEntity* se_ptr )
287 : : {
288 [ + - ][ + - ]: 160776 : if (se_ptr->dag_type() != dag_type().parent())
[ + - ][ - + ]
289 : 0 : return CUBIT_FAILURE;
290 : :
291 [ - + ]: 160776 : if (se_ptr->get_basic_topology_entity_ptr())
292 : 0 : return CUBIT_FAILURE;
293 : :
294 [ - + ]: 160776 : assert(!se_ptr->next_on_bte());
295 [ + + ]: 160776 : if (firstSenseEntity)
296 : : {
297 [ - + ]: 82084 : assert(!lastSenseEntity->next_on_bte());
298 : 82084 : lastSenseEntity->set_bte_next(se_ptr);
299 : : }
300 : : else
301 : : {
302 : 78692 : firstSenseEntity = se_ptr;
303 : : }
304 : :
305 : 160776 : lastSenseEntity = se_ptr;
306 : 160776 : se_ptr->set_basic_topology_entity_ptr(this);
307 : 160776 : return CUBIT_SUCCESS;
308 : : }
309 : :
310 : : //-------------------------------------------------------------------------
311 : : // Purpose : Disconnect parent sense entity
312 : : //
313 : : // Special Notes :
314 : : //
315 : : // Creator : Jason Kraftcheck
316 : : //
317 : : // Creation Date : 07/22/03
318 : : //-------------------------------------------------------------------------
319 : 100400 : CubitStatus BasicTopologyEntity::remove_sense_entity( SenseEntity* se_ptr)
320 : : {
321 [ - + ]: 100400 : if (se_ptr->get_basic_topology_entity_ptr() != this)
322 : 0 : { assert(0); return CUBIT_FAILURE; }
323 : :
324 [ - + ]: 100400 : if (!firstSenseEntity)
325 : 0 : return CUBIT_FAILURE;
326 : :
327 [ + + ]: 100400 : if (firstSenseEntity == se_ptr)
328 : : {
329 [ + + ]: 83457 : if (lastSenseEntity == se_ptr)
330 : : {
331 : 48795 : firstSenseEntity = lastSenseEntity = 0;
332 : : }
333 : : else
334 : : {
335 : 83457 : firstSenseEntity = se_ptr->next_on_bte();
336 : : }
337 : : }
338 : : else
339 : : {
340 : 16943 : SenseEntity* prev = firstSenseEntity;
341 [ + + ]: 22991 : while (prev->next_on_bte() != se_ptr)
342 : : {
343 : 6048 : prev = prev->next_on_bte();
344 [ - + ]: 6048 : if (!prev)
345 : 0 : return CUBIT_FAILURE;
346 : : }
347 : :
348 : 16943 : prev->set_bte_next( se_ptr->next_on_bte() );
349 [ + + ]: 16943 : if (lastSenseEntity == se_ptr)
350 : 9150 : lastSenseEntity = prev;
351 : : }
352 : :
353 : 100400 : se_ptr->set_bte_next(0);
354 : 100400 : se_ptr->set_basic_topology_entity_ptr(0);
355 : 100400 : return CUBIT_SUCCESS;
356 : : }
357 : :
358 : : //-------------------------------------------------------------------------
359 : : // Purpose : Find connecting sense entity
360 : : //
361 : : // Special Notes :
362 : : //
363 : : // Creator : Jason Kraftcheck
364 : : //
365 : : // Creation Date : 07/22/03
366 : : //-------------------------------------------------------------------------
367 : 3317 : SenseEntity* BasicTopologyEntity::find_sense_entity(GroupingEntity* gpe) const
368 : : {
369 : 3317 : SenseEntity *ptr, *result = 0;
370 [ + + ]: 3700 : for (ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
371 : : {
372 [ + - ]: 383 : if (ptr->get_grouping_entity_ptr() == gpe)
373 : : {
374 [ - + ]: 383 : if (result)
375 : 0 : return 0;
376 : 383 : result = ptr;
377 : : }
378 : : }
379 : :
380 : 3317 : return result;
381 : : }
382 : 0 : SenseEntity* BasicTopologyEntity::find_sense_entity(BasicTopologyEntity* bte) const
383 : : {
384 : 0 : SenseEntity *ptr, *result = 0;
385 [ # # ]: 0 : for (ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
386 : : {
387 : 0 : GroupingEntity* gpe = ptr->get_grouping_entity_ptr();
388 [ # # ]: 0 : BasicTopologyEntity* tmp_bte = gpe ? gpe->get_basic_topology_entity_ptr() : 0;
389 [ # # ]: 0 : if (tmp_bte == bte)
390 : : {
391 [ # # ]: 0 : if (result)
392 : 0 : return 0;
393 : 0 : result = ptr;
394 : : }
395 : : }
396 : :
397 : 0 : return result;
398 : : }
399 : :
400 : 0 : CubitStatus BasicTopologyEntity::get_sense_entities(
401 : : DLIList<SenseEntity*>& result,
402 : : GroupingEntity* in_this )
403 : : {
404 : 0 : int input_size = result.size();
405 : :
406 [ # # ][ # # ]: 0 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
407 [ # # ][ # # ]: 0 : if (!in_this || ptr->get_grouping_entity_ptr() == in_this)
[ # # ][ # # ]
408 [ # # ]: 0 : result.append(ptr);
409 : :
410 [ # # ]: 0 : return result.size() > input_size ? CUBIT_SUCCESS : CUBIT_FAILURE;
411 : : }
412 : :
413 : 32296 : CubitStatus BasicTopologyEntity::get_sense_entities(
414 : : DLIList<SenseEntity*>& result,
415 : : BasicTopologyEntity* in_this )
416 : : {
417 : 32296 : int input_size = result.size();
418 : :
419 [ + - ][ + + ]: 86522 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
420 [ + - ][ + - ]: 54226 : if (!in_this || ptr->get_parent_basic_topology_entity_ptr() == in_this)
[ + + ][ + + ]
421 [ + - ]: 32706 : result.append(ptr);
422 : :
423 [ + - ]: 32296 : return result.size() > input_size ? CUBIT_SUCCESS : CUBIT_FAILURE;
424 : : }
425 : :
426 : : //-------------------------------------------------------------------------
427 : : // Purpose : Check if this entity is nonmanifold in the parent
428 : : // sense entity.
429 : : //
430 : : // Special Notes :
431 : : //
432 : : // Creator : Jason Kraftcheck
433 : : //
434 : : // Creation Date : 07/22/03
435 : : //-------------------------------------------------------------------------
436 : 55 : CubitBoolean BasicTopologyEntity::is_nonmanifold(GroupingEntity* gpe)
437 : : {
438 : 55 : int count = 0;
439 [ + + ]: 143 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
440 [ + - ]: 88 : if (ptr->get_grouping_entity_ptr() == gpe)
441 : 88 : count++;
442 : :
443 [ - + ]: 55 : assert(count);
444 [ + + ]: 55 : return count == 1 ? CUBIT_FALSE : CUBIT_TRUE;
445 : : }
446 : :
447 : 4794 : GeometryType BasicTopologyEntity::geometry_type() const
448 : : {
449 : : //- returns type of underlying geometry representation
450 : : //- (see GeometryEntity.hpp for list of types)
451 : 4794 : return get_geometry_entity_ptr()->geometry_type();
452 : : }
453 : :
454 : : //-------------------------------------------------------------------------
455 : : // Purpose : These functions return the GeometryEntity of this
456 : : // BasicTopologyEntity.
457 : : //
458 : : // Special Notes :
459 : : //
460 : : // Creator : Malcolm J. Panthaki
461 : : //
462 : : // Creation Date : 07/31/96
463 : : //-------------------------------------------------------------------------
464 : 600325 : GeometryEntity* BasicTopologyEntity::get_geometry_entity_ptr() const
465 : : {
466 : 600325 : TopologyBridge* bridge = bridge_manager()->topology_bridge();
467 [ + + ]: 600325 : return dynamic_cast<GeometryEntity*>(bridge);
468 : : }
469 : :
470 : :
471 : 36204 : CubitBox BasicTopologyEntity::bounding_box()
472 : : {
473 : 36204 : return get_geometry_entity_ptr()->bounding_box() ;
474 : : }
475 : :
476 : : // Function to get the bounding box of all of the entities in the merge. This
477 : : // loop through all of the bridges in the bridge list of a merged entity
478 : : // and get an aggregate bounding box for all of them.
479 : 872 : CubitBox BasicTopologyEntity::unmerged_bounding_box()
480 : : {
481 [ + + ]: 872 : if(bridge_manager()->number_of_bridges() == 1)
482 : : {
483 : 792 : return get_geometry_entity_ptr()->bounding_box() ;
484 : : }
485 : : else
486 : : {
487 [ + - ]: 80 : CubitBox aggregate_box;
488 [ + - ][ + - ]: 160 : DLIList<TopologyBridge*> bridges;
489 [ + - ][ + - ]: 80 : bridge_manager()->get_bridge_list(bridges);
490 [ + - ][ - + ]: 80 : GeometryEntity *ge = dynamic_cast<GeometryEntity*>(bridges.get_and_step());
491 [ + - ]: 80 : if(ge)
492 [ + - ][ + - ]: 80 : aggregate_box = ge->bounding_box();
[ + - ]
493 : : int i;
494 [ + - ][ + + ]: 160 : for(i=bridges.size(); i>1; i--)
495 : : {
496 [ + - ][ - + ]: 80 : ge = dynamic_cast<GeometryEntity*>(bridges.get_and_step());
497 [ + - ]: 80 : if(ge)
498 [ + - ][ + - ]: 80 : aggregate_box |= ge->bounding_box();
[ + - ]
499 : : }
500 [ + - ][ + - ]: 952 : return aggregate_box;
501 : : }
502 : : }
503 : :
504 : : //-------------------------------------------------------------------------
505 : : // Purpose : Set the GeometryEntity pointer of this BTE
506 : : //
507 : : // Special Notes :
508 : : //
509 : : // Creator : Raikanta Sahu
510 : : //
511 : : // Creation Date : 10/24/96
512 : : //-------------------------------------------------------------------------
513 : 78626 : CubitStatus BasicTopologyEntity::set_geometry_entity_ptr(
514 : : GeometryEntity* GE_ptr)
515 : : {
516 : : // if (dag_type().dimension() != GE_ptr.dimension())
517 : : // {
518 : : // PRINT_ERROR("Internal Error: %s:%d: Mismatched BTE/GeometryEntity.\n",
519 : : // __FILE__,__LINE__);
520 : : // return CUBIT_FAILURE;
521 : : // }
522 : 78626 : return TopologyEntity::set_topology_bridge(GE_ptr);
523 : : }
524 : :
525 : 106 : double BasicTopologyEntity::measure()
526 : 106 : { return get_geometry_entity_ptr()->measure(); }
527 : :
528 : : //-------------------------------------------------------------------------
529 : : // Purpose : get parent sense entities
530 : : //
531 : : // Special Notes :
532 : : //
533 : : // Creator : Jason Kraftcheck
534 : : //
535 : : // Creation Date : 07/22/03
536 : : //-------------------------------------------------------------------------
537 : 100456 : int BasicTopologyEntity::get_parents( DLIList<TopologyEntity*>* list ) const
538 : : {
539 [ + + ]: 100456 : if (!firstSenseEntity)
540 : 48950 : return 0;
541 : :
542 : 51506 : int count = 0;
543 : : SenseEntity* ptr;
544 : :
545 [ + + ]: 125028 : for (ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
546 : : {
547 : 73522 : count++;
548 [ - + ]: 73522 : if (list)
549 [ # # ]: 0 : list->append(ptr);
550 : : }
551 : :
552 : 100456 : return count;
553 : : }
554 : :
555 : :
556 : :
557 : : //-------------------------------------------------------------------------
558 : : // Purpose : get child grouping entities
559 : : //
560 : : // Special Notes :
561 : : //
562 : : // Creator : Jason Kraftcheck
563 : : //
564 : : // Creation Date : 07/22/03
565 : : //-------------------------------------------------------------------------
566 : 0 : int BasicTopologyEntity::get_children( DLIList<TopologyEntity*>* list ) const
567 : : {
568 [ # # ]: 0 : if (!firstGroupingEntity)
569 : 0 : return 0;
570 : :
571 : 0 : int count = 0;
572 : : GroupingEntity* ptr;
573 : :
574 [ # # ]: 0 : for (ptr = firstGroupingEntity; ptr; ptr = ptr->next())
575 : : {
576 : 0 : count++;
577 [ # # ]: 0 : if (list)
578 [ # # ]: 0 : list->append(ptr);
579 : : }
580 : :
581 : 0 : return count;
582 : : }
583 : :
584 : : //-------------------------------------------------------------------------
585 : : // Purpose : Functions to support ModelQueryEngine
586 : : //
587 : : // Special Notes :
588 : : //
589 : : // Creator : Jason Kraftcheck
590 : : //
591 : : // Creation Date : 07/24/03
592 : : //-------------------------------------------------------------------------
593 : 97478 : CubitBoolean BasicTopologyEntity::query_append_parents( DLIList<TopologyEntity*>& list )
594 : : {
595 [ + + ]: 97478 : if (!firstSenseEntity)
596 : 16453 : return CUBIT_FALSE;
597 : :
598 : :
599 : 81025 : CubitBoolean found_some = CUBIT_FALSE;
600 : 81025 : ModelQueryEngine *const mqe = ModelQueryEngine::instance();
601 [ + + ]: 251695 : for (SenseEntity* ptr = firstSenseEntity; ptr; ptr = ptr->next_on_bte())
602 [ + + ]: 170670 : if (!mqe->encountered(ptr))
603 : : {
604 [ + - ]: 167449 : list.append(ptr);
605 : 167449 : found_some = CUBIT_TRUE;
606 : : }
607 : :
608 : 97478 : return found_some;
609 : : }
610 : 508579 : CubitBoolean BasicTopologyEntity::query_append_children( DLIList<TopologyEntity*>& list )
611 : : {
612 [ - + ]: 508579 : if (!firstGroupingEntity)
613 : 0 : return 0;
614 : :
615 : 508579 : CubitBoolean found_some = CUBIT_FALSE;
616 : 508579 : ModelQueryEngine *const mqe = ModelQueryEngine::instance();
617 : : GroupingEntity* ptr;
618 : :
619 [ + + ]: 1034056 : for (ptr = firstGroupingEntity; ptr; ptr = ptr->next())
620 : : {
621 [ + + ]: 525477 : if (!mqe->encountered(ptr))
622 : : {
623 : 521328 : found_some = CUBIT_TRUE;
624 [ + - ]: 521328 : list.append(ptr);
625 : : }
626 : : }
627 : :
628 : 508579 : return found_some;
629 : : }
630 : :
631 : : //-------------------------------------------------------------------------
632 : : // Purpose : Generic function to remove child grouping entity
633 : : //
634 : : // Special Notes :
635 : : //
636 : : // Creator : Jason Kraftcheck
637 : : //
638 : : // Creation Date : 07/22/03
639 : : //-------------------------------------------------------------------------
640 : 0 : CubitStatus BasicTopologyEntity::remove_child_link(TopologyEntity* entity_ptr)
641 : : {
642 [ # # ]: 0 : GroupingEntity* gpe_ptr = dynamic_cast<GroupingEntity*>(entity_ptr);
643 [ # # ]: 0 : if (!gpe_ptr)
644 : 0 : return CUBIT_FAILURE;
645 : :
646 : 0 : return remove_grouping_entity(gpe_ptr);
647 : : }
648 : :
649 : : //-------------------------------------------------------------------------
650 : : // Purpose : Remove from parent SenseEntitys
651 : : //
652 : : // Special Notes :
653 : : //
654 : : // Creator : Jason Kraftcheck
655 : : //
656 : : // Creation Date : 07/22/03
657 : : //-------------------------------------------------------------------------
658 : 0 : CubitStatus BasicTopologyEntity::disconnect_all_parents( DLIList<TopologyEntity*>* list )
659 : : {
660 [ # # ]: 0 : while (firstSenseEntity)
661 : : {
662 : 0 : SenseEntity* se_ptr = firstSenseEntity;
663 : :
664 [ # # ]: 0 : if (!remove_sense_entity(se_ptr))
665 : 0 : return CUBIT_FAILURE;
666 : :
667 [ # # ]: 0 : if (list)
668 [ # # ]: 0 : list->append(se_ptr);
669 : : }
670 : 0 : return CUBIT_SUCCESS;
671 : : }
672 : :
673 : : //-------------------------------------------------------------------------
674 : : // Purpose : Disconnect child GroupingEntities
675 : : //
676 : : // Special Notes :
677 : : //
678 : : // Creator : Jason Kraftcheck
679 : : //
680 : : // Creation Date : 07/22/03
681 : : //-------------------------------------------------------------------------
682 : 47850 : CubitStatus BasicTopologyEntity::disconnect_all_children( DLIList<TopologyEntity*>* list )
683 : : {
684 [ + + ]: 81303 : while (firstGroupingEntity)
685 : : {
686 : 33453 : GroupingEntity* gpe_ptr = firstGroupingEntity;
687 : :
688 [ - + ]: 33453 : if (!remove_grouping_entity(gpe_ptr))
689 : 0 : return CUBIT_FAILURE;
690 : :
691 [ + - ]: 33453 : if (list)
692 [ + - ]: 33453 : list->append(gpe_ptr);
693 : : }
694 : 47850 : return CUBIT_SUCCESS;
695 [ + - ][ + - ]: 6540 : }
696 : :
697 : :
698 : :
699 : : // ********** END PUBLIC FUNCTIONS **********
700 : :
701 : : // ********** BEGIN PROTECTED FUNCTIONS **********
702 : :
703 : : // ********** END PROTECTED FUNCTIONS **********
704 : :
705 : : // ********** BEGIN PRIVATE FUNCTIONS **********
706 : :
707 : : // ********** END PRIVATE FUNCTIONS **********
708 : :
709 : : // ********** BEGIN HELPER CLASSES **********
710 : : // ********** END HELPER CLASSES **********
711 : :
712 : : // ********** BEGIN EXTERN FUNCTIONS **********
713 : : // ********** END EXTERN FUNCTIONS **********
714 : :
715 : : // ********** BEGIN STATIC FUNCTIONS **********
716 : : // ********** END STATIC FUNCTIONS **********
717 : :
|
