Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : TopologyBridge.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Creator : Tim Tautges
7 : : //
8 : : // Creation Date : 03/22/99
9 : : //
10 : : // Owner : Darryl Melander
11 : : //-------------------------------------------------------------------------
12 : : #include "TopologyBridge.hpp"
13 : : #include "TopologyEntity.hpp"
14 : : #include "DLIList.hpp"
15 : : #include "BodySM.hpp"
16 : : #include "Lump.hpp"
17 : : #include "ShellSM.hpp"
18 : : #include "Surface.hpp"
19 : : #include "LoopSM.hpp"
20 : : #include "Curve.hpp"
21 : : #include "CoEdgeSM.hpp"
22 : : #include "Point.hpp"
23 : : #include "CubitSimpleAttrib.hpp"
24 : : #include "BridgeManager.hpp"
25 : : #include "TBOwner.hpp"
26 : : #include "TBOwnerSet.hpp"
27 : : #include "CADefines.hpp"
28 : :
29 : 105388 : TopologyBridge::~TopologyBridge()
30 : : {
31 [ + + ]: 105388 : if (bridgeOwner)
32 : 103001 : bridgeOwner->bridge_destroyed(this);
33 [ - + ]: 105388 : }
34 : :
35 : 434574 : TopologyEntity* TopologyBridge::topology_entity() const
36 : : {
37 : 434574 : BridgeManager* bridgeManager = bridge_manager();
38 [ + + ]: 434574 : if (bridgeManager)
39 : 264591 : return bridgeManager->topology_entity();
40 : : else
41 : 169983 : return NULL;
42 : : }
43 : :
44 : 11 : BodySM *TopologyBridge::bodysm()
45 : : {
46 [ + - ]: 11 : DLIList<BodySM*> bodies;
47 [ + - ]: 11 : bodysms(bodies);
48 [ + - ][ + - ]: 11 : if (bodies.size() > 0) return bodies.get();
[ + - ]
49 [ + - ]: 11 : else return NULL;
50 : : }
51 : :
52 : 0 : Lump *TopologyBridge::lump()
53 : : {
54 [ # # ]: 0 : DLIList<Lump*> lump_list;
55 [ # # ]: 0 : lumps(lump_list);
56 [ # # ][ # # ]: 0 : if (lump_list.size() > 0) return lump_list.get();
[ # # ]
57 [ # # ]: 0 : else return NULL;
58 : : }
59 : :
60 : :
61 : 0 : LoopSM *TopologyBridge::loopsm()
62 : : {
63 [ # # ]: 0 : DLIList<LoopSM*> loopsm_list;
64 [ # # ]: 0 : loopsms(loopsm_list);
65 [ # # ][ # # ]: 0 : if (loopsm_list.size() > 0) return loopsm_list.get();
[ # # ]
66 [ # # ]: 0 : else return NULL;
67 : : }
68 : :
69 : :
70 : :
71 : :
72 : 33 : void TopologyBridge::bodysms( DLIList<BodySM*>& bodies, bool unique )
73 : : {
74 [ + - ]: 33 : DLIList<TopologyBridge*> parents;
75 [ - + ]: 33 : BodySM* this_body = dynamic_cast<BodySM*>(this);
76 [ - + ]: 33 : if( this_body )
77 : : {
78 [ # # ]: 0 : bodies.append( this_body );
79 : : }
80 [ + - ][ + + ]: 33 : else if( dynamic_cast<Lump*>(this) )
81 : : {
82 [ + - ]: 11 : get_parents( parents );
83 [ + - ]: 11 : parents.reset();
84 [ + - ][ + + ]: 22 : for ( int i = parents.size(); i--; )
85 [ + - ][ - + ]: 22 : bodies.append (dynamic_cast<BodySM*>(parents.get_and_step()));
[ + - ]
86 : : }
87 : : else
88 : : {
89 [ + - ]: 22 : get_parents( parents );
90 [ + - ][ + + ]: 44 : for( int i = parents.size(); i--; )
91 [ + - ][ + - ]: 22 : parents.get_and_step()->bodysms( bodies, false );
92 : :
93 [ + + ]: 22 : if (unique)
94 [ + - ]: 11 : bodies.uniquify_ordered();
95 [ + - ]: 33 : }
96 : 33 : }
97 : :
98 : 7698 : void TopologyBridge::lumps( DLIList<Lump*>& lumps, bool unique )
99 : : {
100 [ + - ]: 7698 : DLIList<TopologyBridge*> related;
101 [ - + ]: 7698 : Lump* this_lump = dynamic_cast<Lump*>(this);
102 [ - + ]: 7698 : if( this_lump )
103 : : {
104 [ # # ]: 0 : lumps.append( this_lump );
105 : : }
106 [ + - ][ + - ]: 7698 : else if( dynamic_cast<BodySM*>(this) )
107 : : {
108 [ + - ]: 7698 : get_children( related );
109 [ + - ]: 7698 : related.reset();
110 [ + - ][ + + ]: 16026 : for ( int i = related.size(); i--; )
111 [ + - ][ - + ]: 16026 : lumps.append( dynamic_cast<Lump*>(related.get_and_step()) );
[ + - ]
112 : : }
113 [ # # ][ # # ]: 0 : else if( dynamic_cast<ShellSM*>(this) )
114 : : {
115 [ # # ]: 0 : get_parents( related );
116 [ # # ]: 0 : related.reset();
117 [ # # ][ # # ]: 0 : for ( int i = related.size(); i--; )
118 [ # # ][ # # ]: 0 : lumps.append( dynamic_cast<Lump*>(related.get_and_step()) );
[ # # ]
119 : : }
120 : : else
121 : : {
122 [ # # ]: 0 : get_parents( related );
123 [ # # ][ # # ]: 0 : for( int i = related.size(); i--; )
124 [ # # ][ # # ]: 0 : related.get_and_step()->lumps( lumps, false );
125 : :
126 [ # # ]: 0 : if (unique)
127 [ # # ]: 0 : lumps.uniquify_ordered();
128 [ + - ]: 7698 : }
129 : 7698 : }
130 : :
131 : 3991 : void TopologyBridge::shellsms( DLIList<ShellSM*>& shells, bool unique )
132 : : {
133 [ + - ]: 3991 : DLIList<TopologyBridge*> related;
134 [ - + ]: 3991 : ShellSM* this_shell = dynamic_cast<ShellSM*>(this);
135 [ - + ]: 3991 : if( this_shell )
136 : : {
137 [ # # ]: 0 : shells.append(this_shell);
138 : : }
139 [ + - ][ + + ]: 3991 : else if( dynamic_cast<Lump*>(this) )
140 : : {
141 [ + - ]: 3317 : get_children( related );
142 [ + - ]: 3317 : related.reset();
143 [ + - ][ + + ]: 6694 : for ( int i = related.size(); i--; )
144 [ + - ][ - + ]: 6694 : shells.append( dynamic_cast<ShellSM*>(related.get_and_step()) );
[ + - ]
145 : : }
146 [ + - ][ + - ]: 674 : else if( dynamic_cast<Surface*>(this) )
147 : : {
148 [ + - ]: 674 : get_parents( related );
149 [ + - ]: 674 : related.reset();
150 [ + - ][ + + ]: 1348 : for ( int i = related.size(); i--; )
151 [ + - ][ - + ]: 1348 : shells.append( dynamic_cast<ShellSM*>(related.get_and_step()) );
[ + - ]
152 : : }
153 [ # # ][ # # ]: 0 : else if( dynamic_cast<BodySM*>(this) )
154 : : {
155 [ # # ]: 0 : get_children( related );
156 [ # # ][ # # ]: 0 : for ( int i = related.size(); i--; )
157 [ # # ][ # # ]: 0 : related.get_and_step()->shellsms( shells );
158 : : }
159 : : else
160 : : {
161 [ # # ]: 0 : get_parents( related );
162 : :
163 [ # # ][ # # ]: 0 : for( int i = related.size(); i--; )
164 [ # # ][ # # ]: 0 : related.get_and_step()->shellsms( shells, false );
165 : :
166 [ # # ]: 0 : if ( unique )
167 [ # # ]: 0 : shells.uniquify_ordered();
168 [ + - ]: 3991 : }
169 : 3991 : }
170 : :
171 : 25602 : void TopologyBridge::surfaces( DLIList<Surface*>& surfaces, bool unique )
172 : : {
173 [ + - ]: 25602 : DLIList<TopologyBridge*> related;
174 [ - + ]: 25602 : Surface* this_surf = dynamic_cast<Surface*>(this);
175 [ - + ]: 25602 : if( this_surf )
176 : : {
177 [ # # ]: 0 : surfaces.append(this_surf);
178 : : }
179 [ + - ][ + + ]: 25602 : else if( dynamic_cast<LoopSM*>(this) )
180 : : {
181 [ + - ]: 369 : get_parents( related );
182 [ + - ]: 369 : related.reset();
183 [ + - ][ + + ]: 738 : for (int i = related.size(); i--; )
184 [ + - ][ - + ]: 738 : surfaces.append( dynamic_cast<Surface*>(related.get_and_step()) );
[ + - ]
185 : : }
186 [ + - ][ + + ]: 25233 : else if( dynamic_cast<ShellSM*>(this) )
187 : : {
188 [ + - ]: 11572 : get_children( related );
189 [ + - ]: 11572 : related.reset();
190 [ + - ][ + + ]: 78705 : for (int i = related.size(); i--; )
191 [ + - ][ - + ]: 78705 : surfaces.append( dynamic_cast<Surface*>(related.get_and_step()) );
[ + - ]
192 : : }
193 [ + - ][ + + ]: 13661 : else if ( dynamic_cast<BodySM*>(this) || dynamic_cast<Lump*>(this) )
[ + - ][ + + ]
194 : : {
195 [ + - ]: 13292 : get_children(related);
196 [ + - ]: 13292 : related.reset();
197 [ + - ][ + + ]: 27362 : for (int i = related.size(); i--; )
198 [ + - ][ + - ]: 14070 : related.get_and_step()->surfaces( surfaces, false );
199 : :
200 [ + + ]: 13292 : if (unique)
201 [ + - ]: 13292 : surfaces.uniquify_ordered();
202 : : }
203 : : else
204 : : {
205 [ + - ]: 369 : get_parents(related);
206 [ + - ]: 369 : related.reset();
207 [ + - ][ + + ]: 738 : for (int i = related.size(); i--; )
208 [ + - ][ + - ]: 369 : related.get_and_step()->surfaces( surfaces, false );
209 : :
210 [ + - ][ + - ]: 369 : if (unique && !dynamic_cast<CoEdgeSM*>(this))
[ - + ]
211 [ # # ]: 0 : related.uniquify_ordered();
212 [ + - ]: 25602 : }
213 : 25602 : }
214 : :
215 : 38036 : void TopologyBridge::loopsms( DLIList<LoopSM*>& loops, bool unique )
216 : : {
217 [ + - ]: 38036 : DLIList<TopologyBridge*> related;
218 : :
219 [ - + ]: 38036 : LoopSM* this_loop = dynamic_cast<LoopSM*>(this);
220 [ - + ]: 38036 : if( this_loop )
221 : : {
222 [ # # ]: 0 : loops.append(this_loop);
223 : : }
224 [ + - ][ + + ]: 38036 : else if( dynamic_cast<CoEdgeSM*>(this ) )
225 : : {
226 [ + - ]: 82 : get_parents( related );
227 [ + - ]: 82 : related.reset();
228 [ + - ][ + + ]: 164 : for (int i = related.size(); i--; )
229 [ + - ][ - + ]: 164 : loops.append( dynamic_cast<LoopSM*>(related.get_and_step()) );
[ + - ]
230 : : }
231 [ + - ][ + - ]: 37954 : else if( dynamic_cast<Surface*>(this) )
232 : : {
233 [ + - ]: 37954 : get_children( related );
234 [ + - ]: 37954 : related.reset();
235 [ + - ][ + + ]: 78222 : for (int i = related.size(); i--; )
236 [ + - ][ - + ]: 78222 : loops.append( dynamic_cast<LoopSM*>(related.get_and_step()) );
[ + - ]
237 : : }
238 : : else
239 : : {
240 [ # # ][ # # ]: 0 : if( dynamic_cast<Curve*>(this) || dynamic_cast<TBPoint*>(this) )
[ # # ][ # # ]
241 [ # # ]: 0 : get_parents( related );
242 : : else
243 [ # # ]: 0 : get_children( related );
244 : :
245 [ # # ]: 0 : related.reset();
246 [ # # ][ # # ]: 0 : for( int i = related.size(); i--; )
247 [ # # ][ # # ]: 0 : related.get_and_step()->loopsms( loops, false );
248 : :
249 [ # # ]: 0 : if (unique)
250 [ # # ]: 0 : loops.uniquify_ordered();
251 [ + - ]: 38036 : }
252 : 38036 : }
253 : :
254 : :
255 : 40432 : void TopologyBridge::coedgesms( DLIList<CoEdgeSM*>& coedges, bool unique )
256 : : {
257 [ + - ]: 40432 : DLIList<TopologyBridge*> related;
258 : :
259 [ - + ]: 40432 : CoEdgeSM* this_coedge = dynamic_cast<CoEdgeSM*>(this);
260 [ - + ]: 40432 : if( this_coedge )
261 : : {
262 [ # # ]: 0 : coedges.append(this_coedge);
263 : : }
264 [ + - ][ + + ]: 40432 : else if( dynamic_cast<Curve*>(this) )
265 : : {
266 [ + - ]: 164 : get_parents( related );
267 [ + - ]: 164 : related.reset();
268 [ + - ][ + + ]: 492 : for (int i = related.size(); i--; )
269 [ + - ][ - + ]: 492 : coedges.append( dynamic_cast<CoEdgeSM*>(related.get_and_step()) );
[ + - ]
270 : : }
271 [ + - ][ + - ]: 40268 : else if( dynamic_cast<LoopSM*>(this) )
272 : : {
273 [ + - ]: 40268 : get_children( related );
274 [ + - ]: 40268 : related.reset();
275 [ + - ][ + + ]: 193764 : for (int i = related.size(); i--; )
276 [ + - ][ - + ]: 193764 : coedges.append( dynamic_cast<CoEdgeSM*>(related.get_and_step()) );
[ + - ]
277 : : }
278 : : else
279 : : {
280 [ # # ][ # # ]: 0 : if( dynamic_cast<TBPoint*>(this) )
281 [ # # ]: 0 : get_parents( related );
282 : : else
283 [ # # ]: 0 : get_children( related );
284 : :
285 [ # # ]: 0 : related.reset();
286 [ # # ][ # # ]: 0 : for( int i = related.size(); i--; )
287 [ # # ][ # # ]: 0 : related.get_and_step()->coedgesms(coedges, false);
288 : :
289 [ # # ]: 0 : if (unique)
290 [ # # ]: 0 : coedges.uniquify_ordered();
291 [ + - ]: 40432 : }
292 : 40432 : }
293 : :
294 : 0 : void TopologyBridge::curves_ignore_virtual( DLIList<Curve*>& curves, bool unique )
295 : : {
296 : : int i;
297 [ # # ][ # # ]: 0 : if(dynamic_cast<BodySM*>(this))
298 : : {
299 [ # # ]: 0 : DLIList<TopologyBridge*> lumps;
300 [ # # ]: 0 : this->get_children_virt(lumps);
301 [ # # ][ # # ]: 0 : for(i=lumps.size(); i>0; i--)
302 [ # # ][ # # ]: 0 : lumps.get_and_step()->curves_ignore_virtual(curves, unique);
[ # # ]
303 : : }
304 [ # # ][ # # ]: 0 : else if(dynamic_cast<Lump*>(this))
305 : : {
306 [ # # ]: 0 : DLIList<TopologyBridge*> shells;
307 [ # # ]: 0 : this->get_children_virt(shells);
308 [ # # ][ # # ]: 0 : for(i=shells.size(); i>0; i--)
309 [ # # ][ # # ]: 0 : shells.get_and_step()->curves_ignore_virtual(curves, unique);
[ # # ]
310 : : }
311 [ # # ][ # # ]: 0 : else if(dynamic_cast<ShellSM*>(this))
312 : : {
313 [ # # ]: 0 : DLIList<TopologyBridge*> surfs;
314 [ # # ]: 0 : this->get_children_virt(surfs);
315 [ # # ][ # # ]: 0 : for(i=surfs.size(); i>0; i--)
316 [ # # ][ # # ]: 0 : surfs.get_and_step()->curves_ignore_virtual(curves, unique);
[ # # ]
317 : : }
318 [ # # ][ # # ]: 0 : else if(dynamic_cast<Surface*>(this))
319 : : {
320 [ # # ]: 0 : DLIList<TopologyBridge*> loops;
321 [ # # ]: 0 : this->get_children_virt(loops);
322 [ # # ][ # # ]: 0 : for(i=loops.size(); i>0; i--)
323 [ # # ][ # # ]: 0 : loops.get_and_step()->curves_ignore_virtual(curves, unique);
[ # # ]
324 : : }
325 [ # # ][ # # ]: 0 : else if(dynamic_cast<LoopSM*>(this))
326 : : {
327 [ # # ]: 0 : DLIList<TopologyBridge*> coedges;
328 [ # # ]: 0 : this->get_children_virt(coedges);
329 [ # # ][ # # ]: 0 : for(i=coedges.size(); i>0; i--)
330 [ # # ][ # # ]: 0 : coedges.get_and_step()->curves_ignore_virtual(curves, unique);
[ # # ]
331 : : }
332 [ # # ][ # # ]: 0 : else if(dynamic_cast<CoEdgeSM*>(this))
333 : : {
334 [ # # ]: 0 : DLIList<TopologyBridge*> tmp_curves;
335 [ # # ]: 0 : this->get_children_virt(tmp_curves);
336 [ # # ][ # # ]: 0 : for(i=tmp_curves.size(); i>0; i--)
337 [ # # ][ # # ]: 0 : tmp_curves.get_and_step()->curves_ignore_virtual(curves, unique);
[ # # ]
338 : : }
339 [ # # ][ # # ]: 0 : else if(dynamic_cast<Curve*>(this))
340 : : {
341 [ # # ][ # # ]: 0 : curves.append(dynamic_cast<Curve*>(this));
342 : : }
343 [ # # ]: 0 : if(unique)
344 : 0 : curves.uniquify_ordered();
345 : 0 : }
346 : :
347 : 0 : void TopologyBridge::surfaces_ignore_virtual( DLIList<Surface*>& surfaces, bool unique )
348 : : {
349 : : int i;
350 [ # # ][ # # ]: 0 : if(dynamic_cast<BodySM*>(this))
351 : : {
352 [ # # ]: 0 : DLIList<TopologyBridge*> lumps;
353 [ # # ]: 0 : this->get_children_virt(lumps);
354 [ # # ][ # # ]: 0 : for(i=lumps.size(); i>0; i--)
355 [ # # ][ # # ]: 0 : lumps.get_and_step()->surfaces_ignore_virtual(surfaces, unique);
[ # # ]
356 : : }
357 [ # # ][ # # ]: 0 : else if(dynamic_cast<Lump*>(this))
358 : : {
359 [ # # ]: 0 : DLIList<TopologyBridge*> shells;
360 [ # # ]: 0 : this->get_children_virt(shells);
361 [ # # ][ # # ]: 0 : for(i=shells.size(); i>0; i--)
362 [ # # ][ # # ]: 0 : shells.get_and_step()->surfaces_ignore_virtual(surfaces, unique);
[ # # ]
363 : : }
364 [ # # ][ # # ]: 0 : else if(dynamic_cast<ShellSM*>(this))
365 : : {
366 [ # # ]: 0 : DLIList<TopologyBridge*> surfs;
367 [ # # ]: 0 : this->get_children_virt(surfs);
368 [ # # ][ # # ]: 0 : for(i=surfs.size(); i>0; i--)
369 [ # # ][ # # ]: 0 : surfs.get_and_step()->surfaces_ignore_virtual(surfaces, unique);
[ # # ]
370 : : }
371 [ # # ][ # # ]: 0 : else if(dynamic_cast<Surface*>(this))
372 : : {
373 [ # # ][ # # ]: 0 : surfaces.append(dynamic_cast<Surface*>(this));
374 : : }
375 [ # # ]: 0 : if(unique)
376 : 0 : surfaces.uniquify_ordered();
377 : 0 : }
378 : :
379 : 479923 : void TopologyBridge::curves( DLIList<Curve*>& curves, bool unique )
380 : : {
381 [ + - ]: 479923 : DLIList<TopologyBridge*> related;
382 : :
383 [ - + ]: 479923 : Curve* this_curve = dynamic_cast<Curve*>(this);
384 [ - + ]: 479923 : if( this_curve )
385 : : {
386 [ # # ]: 0 : curves.append(this_curve);
387 : : }
388 [ + - ][ - + ]: 479923 : else if( dynamic_cast<TBPoint*>(this) )
389 : : {
390 [ # # ]: 0 : get_parents( related );
391 [ # # ]: 0 : related.reset();
392 [ # # ][ # # ]: 0 : for (int i = related.size(); i--; )
393 [ # # ][ # # ]: 0 : curves.append( dynamic_cast<Curve*>(related.get_and_step()) );
[ # # ]
394 : : }
395 [ + - ][ + + ]: 479923 : else if( dynamic_cast<CoEdgeSM*>(this) )
396 : : {
397 [ + - ]: 358998 : get_children( related );
398 [ + - ]: 358998 : related.reset();
399 [ + - ][ + + ]: 717996 : for (int i = related.size(); i--; )
400 [ + - ][ - + ]: 717996 : curves.append( dynamic_cast<Curve*>(related.get_and_step()) );
[ + - ]
401 : : }
402 : : else
403 : : {
404 [ + - ]: 120925 : get_children( related );
405 : :
406 [ + - ]: 120925 : related.reset();
407 [ + - ][ + + ]: 426089 : for (int i = related.size(); i--; )
408 [ + - ][ + - ]: 305164 : related.get_and_step()->curves (curves, false);
409 : :
410 [ + + ]: 120925 : if (unique)
411 [ + - ]: 21181 : curves.uniquify_ordered();
412 [ + - ]: 479923 : }
413 : 479923 : }
414 : :
415 : 227900 : void TopologyBridge::points( DLIList<TBPoint*>& points, bool unique )
416 : : {
417 [ + - ]: 227900 : DLIList<TopologyBridge*> children;
418 : :
419 [ - + ]: 227900 : TBPoint* this_point = dynamic_cast<TBPoint*>(this);
420 [ - + ]: 227900 : if( this_point )
421 : : {
422 [ # # ]: 0 : points.append(this_point);
423 : : }
424 [ + - ][ + + ]: 227900 : else if( dynamic_cast<Curve*>(this) )
425 : : {
426 [ + - ]: 135283 : get_children( children );
427 [ + - ]: 135283 : children.reset();
428 [ + - ][ + + ]: 400708 : for (int i = children.size(); i--; )
429 [ + - ][ - + ]: 400708 : points.append( dynamic_cast<TBPoint*>(children.get_and_step()) );
[ + - ]
430 : : }
431 : : else
432 : : {
433 [ + - ]: 92617 : get_children( children );
434 : :
435 [ + - ][ + + ]: 240990 : for( int i = children.size(); i--; )
436 [ + - ][ + - ]: 148373 : children.get_and_step()->points(points, false);
437 : :
438 [ + + ]: 92617 : if (unique)
439 [ + - ]: 1955 : points.uniquify_ordered();
440 [ + - ]: 227900 : }
441 : 227900 : }
442 : :
443 : 666635 : BridgeManager* TopologyBridge::bridge_manager() const
444 [ + + ]: 666635 : { return dynamic_cast<BridgeManager*>(bridgeOwner); }
445 : :
446 : 0 : void TopologyBridge::bridge_manager( BridgeManager* manager )
447 : 0 : { bridgeOwner = manager; }
448 : :
449 : 25029 : void TopologyBridge::get_parents( DLIList<TopologyBridge*>& parents )
450 : : {
451 : 25029 : parents.clean_out();
452 : 25029 : get_parents_virt( parents );
453 [ + + ]: 68629 : for ( int i = parents.size(); i--; )
454 : : {
455 : 43600 : TopologyBridge* tb_ptr = parents.step_and_get();
456 [ + + ]: 43600 : TBOwnerSet* partition_body = dynamic_cast<TBOwnerSet*>(tb_ptr->owner());
457 [ - + ]: 43600 : if ( partition_body )
458 : : {
459 [ # # ]: 0 : DLIList<TopologyBridge*> owner_list;
460 [ # # ]: 0 : partition_body->get_owners(owner_list);
461 [ # # ][ # # ]: 0 : assert(owner_list.size() == 1);
462 [ # # ][ # # ]: 0 : parents.change_to(owner_list.get());
[ # # ]
463 : : }
464 : : }
465 : 25029 : }
466 : :
467 : : /*
468 : : void TopologyBridge::get_parents( DLIList<TopologyBridge*>& parents,
469 : : int layer, bool return_hidden )
470 : : {
471 : : assert( this->layer() <= layer );
472 : : DLIList<TopologyBridge*> parents_real;
473 : : get_parents_virt( parents_real );
474 : : while( parents_real.size() )
475 : : {
476 : : // order of parent lists not important (i.e. okay if
477 : : // result list is reverse of parents_real.)
478 : : TopologyBridge* parent_real = parents_real.pop();
479 : : TBOwner* owner = parent_real->owner();
480 : :
481 : : TBOwnerSet* set = 0;
482 : : TopologyBridge* composite = 0;
483 : :
484 : : if( !owner || dynamic_cast<BridgeManager*>(owner) )
485 : : {
486 : : parents.append_unique( parent_real );
487 : : }
488 : : else if( set = dynamic_cast<TBOwnerSet*>(owner) )
489 : : {
490 : : if( set->get_owner_layer() > layer )
491 : : {
492 : : parents.append_unique( parent_real );
493 : : }
494 : : else
495 : : {
496 : : DLIList<TopologyBridge*> bridge_set, children;
497 : : set->get_owners( bridge_set );
498 : : for( int i = bridge_set.size(); i--; )
499 : : {
500 : : TopologyBridge* partition = bridge_set.get_and_step();
501 : : children.clean_out();
502 : : partition->get_children_virt( children );
503 : : if( children.is_in_list( this ) )
504 : : parents_real.append_unique( partition );
505 : : }
506 : : }
507 : : }
508 : : else if( composite = dynamic_cast<TopologyBridge*>(owner) )
509 : : {
510 : : if( composite->layer() > layer )
511 : : parents.append_unique(parent_real);
512 : : else
513 : : parents_real.append_unique( composite );
514 : : }
515 : : else if( return_hidden )
516 : : {
517 : : parents.append( parent_real );
518 : : }
519 : : else
520 : : {
521 : : ; // Do nothing. This entity is hidden by some composite.
522 : : }
523 : : }
524 : : }
525 : : */
526 : :
527 : 840379 : void TopologyBridge::get_children( DLIList<TopologyBridge*>& children,
528 : : bool return_hidden, int layer )
529 : : {
530 [ + - ][ - + ]: 840379 : assert(this->layer() <= layer);
531 : :
532 [ + - ][ + + ]: 5042274 : DLIList<TopologyBridge*> child_list[2], partitions;
[ + - ][ + - ]
[ + - # # ]
533 : 840379 : int current = 0;
534 : :
535 [ + - ]: 840379 : get_children_virt( child_list[current] );
536 : : // Note: be careful to return result list in the same order
537 : : // as the child list we got above.
538 : :
539 : 840379 : bool done = false;
540 [ + + ]: 1680758 : while( !done )
541 : : {
542 : 840379 : done = true;
543 : :
544 : 840379 : int next = 1 - current;
545 [ + - ]: 840379 : child_list[current].reset();
546 [ + - ]: 840379 : child_list[next].clean_out();
547 [ + - ][ + + ]: 2244995 : for( int i = child_list[current].size(); i--; )
548 : : {
549 [ + - ]: 1404616 : TopologyBridge* child = child_list[current].get_and_step();
550 [ + - ]: 1404616 : TBOwner* owner = child->owner();
551 : :
552 : 1404616 : TopologyBridge* composite = 0;
553 : 1404616 : TBOwnerSet* partition = 0;
554 : :
555 [ + + ][ + - ]: 1404616 : if( !owner || dynamic_cast<BridgeManager*>(owner) )
[ + - ][ + - ]
556 : : {
557 [ + - ]: 1404616 : child_list[next].append( child );
558 : : }
559 [ # # ][ # # ]: 0 : else if( (partition = dynamic_cast<TBOwnerSet*>(owner) ) != NULL )
560 : : {
561 [ # # ][ # # ]: 0 : if( partition->get_owner_layer() > layer )
562 : : {
563 [ # # ]: 0 : child_list[next].append(child);
564 : : }
565 : : else
566 : : {
567 : 0 : done = false;
568 [ # # ]: 0 : partitions.clean_out();
569 [ # # ]: 0 : partition->get_owners( partitions );
570 [ # # ]: 0 : partitions.reset();
571 [ # # ]: 0 : child_list[next] += partitions;
572 : : }
573 : : }
574 [ # # ][ # # ]: 0 : else if( (composite = dynamic_cast<TopologyBridge*>(owner) ) != NULL )
575 : : {
576 [ # # ][ # # ]: 0 : if( composite->layer() > layer )
577 : : {
578 [ # # ]: 0 : child_list[next].append(child);
579 : : }
580 : : else
581 : : {
582 : 0 : done = false;
583 [ # # ][ # # ]: 0 : if( !child_list[current].is_in_list(composite) )
584 [ # # ]: 0 : child_list[next].append_unique( composite );
585 : : }
586 : : }
587 [ # # ]: 0 : else if( return_hidden )
588 : : {
589 [ # # ]: 1404616 : child_list[next].append( child );
590 : : }
591 : : else
592 : : {
593 : : ; // Do nothing. This entity is hidden by some composite.
594 : : }
595 : : }
596 : :
597 : 840379 : current = next;
598 : : }
599 : :
600 [ + - ][ + + ]: 3361516 : children = child_list[current];
[ # # ]
601 [ + - ][ + - ]: 846919 : }
[ # # ]
|
