Branch data Line data Source code
1 : : #include "RefEntityFactory.hpp"
2 : : #include "RefVertex.hpp"
3 : : #include "RefEdge.hpp"
4 : : #include "RefFace.hpp"
5 : : #include "RefVolume.hpp"
6 : : #include "Body.hpp"
7 : : #include "RefGroup.hpp"
8 : : #include "GeometryQueryTool.hpp"
9 : : #include "DLIList.hpp"
10 : : #include "AppUtil.hpp"
11 : : #include "GeometryEvent.hpp"
12 : :
13 : 0 : static int sort_by_ascending_ids(CubitEntity*& a, CubitEntity*& b)
14 : : {
15 [ # # ]: 0 : if( a->id() < b->id() )
16 : 0 : return -1;
17 : : else
18 : 0 : return 1;
19 : : }
20 : :
21 : 0 : static int sort_by_ascending_ids(RefVertex*& a, RefVertex*& b)
22 : : {
23 [ # # ]: 0 : if( a->id() < b->id() )
24 : 0 : return -1;
25 : : else
26 : 0 : return 1;
27 : : }
28 : :
29 : 0 : static int sort_by_ascending_ids(RefVolume*& a, RefVolume*& b)
30 : : {
31 [ # # ]: 0 : if( a->id() < b->id() )
32 : 0 : return -1;
33 : : else
34 : 0 : return 1;
35 : : }
36 : :
37 : 4033 : static int sort_by_ascending_ids(RefEdge*& a, RefEdge*& b)
38 : : {
39 [ + + ]: 4033 : if( a->id() < b->id() )
40 : 1017 : return -1;
41 : : else
42 : 3016 : return 1;
43 : : }
44 : :
45 : 340 : static int sort_by_ascending_ids(RefFace*& a, RefFace*& b)
46 : : {
47 [ + + ]: 340 : if( a->id() < b->id() )
48 : 100 : return -1;
49 : : else
50 : 240 : return 1;
51 : : }
52 : :
53 : 2145 : static int sort_by_ascending_ids(Body*& a, Body*& b)
54 : : {
55 [ + + ]: 2145 : if( a->id() < b->id() )
56 : 660 : return -1;
57 : : else
58 : 1485 : return 1;
59 : : }
60 : :
61 : 0 : static int sort_by_ascending_ids(RefGroup*& a, RefGroup*& b)
62 : : {
63 [ # # ]: 0 : if( a->id() < b->id() )
64 : 0 : return -1;
65 : : else
66 : 0 : return 1;
67 : : }
68 : :
69 : : RefEntityFactory *RefEntityFactory::instance_ = NULL;
70 : :
71 : 187655 : RefEntityFactory *RefEntityFactory::instance()
72 : : {
73 [ + + ]: 187655 : if (instance_ == NULL) {
74 [ + - ]: 874 : new RefEntityFactory();
75 : : }
76 : :
77 : 187655 : return instance_;
78 : : }
79 : :
80 : 1748 : RefEntityFactory::RefEntityFactory(bool make_lists)
81 : : {
82 : 874 : instance_ = this;
83 : :
84 [ + - ][ + - ]: 874 : AppUtil::instance()->event_dispatcher().add_observer(this);
[ + - ]
85 : :
86 : :
87 [ + - ]: 874 : if (make_lists) {
88 [ + - ][ + - ]: 874 : refVertexList = new DLIList<RefVertex*>();
89 [ + - ][ + - ]: 874 : refEdgeList = new DLIList<RefEdge*>();
90 [ + - ][ + - ]: 874 : refFaceList = new DLIList<RefFace*>();
91 [ + - ][ + - ]: 874 : refGroupList = new DLIList<RefGroup*>();
92 [ + - ][ + - ]: 874 : refVolumeList = new DLIList<RefVolume*>();
93 [ + - ][ + - ]: 874 : bodyList = new DLIList<Body*>();
94 [ + - ]: 874 : register_observer(this);
95 : : }
96 : : else {
97 : 0 : refVertexList = NULL;
98 : 0 : refEdgeList = NULL;
99 : 0 : refFaceList = NULL;
100 : 0 : refGroupList = NULL;
101 : 0 : refVolumeList = NULL;
102 : 0 : bodyList = NULL;
103 : : }
104 : :
105 : 874 : refVertexListIsSorted = true;
106 : 874 : refEdgeListIsSorted = true;
107 : 874 : refFaceListIsSorted = true;
108 : 874 : refVolumeListIsSorted = true;
109 : 874 : bodyListIsSorted = true;
110 : 874 : refGroupListIsSorted = true;
111 : 874 : ManageListSorting = true;
112 : :
113 [ + - ]: 874 : reset_ids();
114 : 874 : }
115 : :
116 : 0 : void RefEntityFactory::delete_instance()
117 : : {
118 [ # # ]: 0 : if( NULL != instance_ )
119 : : {
120 [ # # ]: 0 : delete instance_;
121 : 0 : instance_ = NULL;
122 : : }
123 : 0 : }
124 : :
125 : 0 : RefEntityFactory::~RefEntityFactory()
126 : : {
127 [ # # ][ # # ]: 0 : if (refVertexList != NULL) delete refVertexList;
[ # # ]
128 [ # # ][ # # ]: 0 : if (refEdgeList != NULL) delete refEdgeList;
[ # # ]
129 [ # # ][ # # ]: 0 : if (refFaceList != NULL) delete refFaceList;
[ # # ]
130 [ # # ][ # # ]: 0 : if (refGroupList != NULL) delete refGroupList;
[ # # ]
131 [ # # ][ # # ]: 0 : if (refVolumeList != NULL) delete refVolumeList;
[ # # ]
132 [ # # ][ # # ]: 0 : if (bodyList != NULL) delete bodyList;
[ # # ]
133 [ # # ]: 0 : unregister_observer(this);
134 : 0 : instance_ = NULL;
135 [ # # ]: 0 : }
136 : :
137 : 24483 : RefVertex *RefEntityFactory::construct_RefVertex(TBPoint *point)
138 : : {
139 [ + - ]: 24483 : RefVertex *temp = new RefVertex(point);
140 [ + - ][ + - ]: 24483 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, temp));
[ + - ]
141 : 24483 : return temp;
142 : : }
143 : :
144 : 35251 : RefEdge *RefEntityFactory::construct_RefEdge(Curve *curve)
145 : : {
146 [ + - ]: 35251 : RefEdge *temp = new RefEdge(curve);
147 [ + - ][ + - ]: 35251 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, temp));
[ + - ]
148 : 35251 : return temp;
149 : : }
150 : :
151 : 16046 : RefFace *RefEntityFactory::construct_RefFace(Surface *surface)
152 : : {
153 [ + - ]: 16046 : RefFace *temp = new RefFace(surface);
154 [ + - ][ + - ]: 16046 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, temp));
[ + - ]
155 : 16046 : return temp;
156 : : }
157 : :
158 : 2846 : RefVolume *RefEntityFactory::construct_RefVolume(Lump *lump)
159 : : {
160 [ + - ]: 2846 : RefVolume *temp = new RefVolume(lump);
161 [ + - ][ + - ]: 2846 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, temp));
[ + - ]
162 : 2846 : return temp;
163 : : }
164 : :
165 : 2716 : Body *RefEntityFactory::construct_Body(BodySM *body_sm)
166 : : {
167 [ + - ]: 2716 : Body *temp = new Body(body_sm);
168 [ + - ][ + - ]: 2716 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, temp));
[ + - ]
169 : 2716 : return temp;
170 : : }
171 : :
172 : 140 : RefGroup *RefEntityFactory::construct_RefGroup(const char* name)
173 : : {
174 [ + - ]: 140 : RefGroup *temp = new RefGroup(name);
175 [ + - ][ + - ]: 140 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, temp));
176 : 140 : return temp;
177 : : }
178 : :
179 : 0 : RefGroup *RefEntityFactory::construct_RefGroup (DLIList<RefEntity*>& entity_list)
180 : : {
181 [ # # ]: 0 : RefGroup *temp = new RefGroup(entity_list);
182 [ # # ][ # # ]: 0 : AppUtil::instance()->send_event(GeometryEvent(GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED, temp));
183 : 0 : return temp;
184 : : }
185 : :
186 : 9258 : CubitStatus RefEntityFactory::ref_entity_list( char const* keyword,
187 : : DLIList<RefEntity*> &entity_list,
188 : : const CubitBoolean print_errors )
189 : : {
190 [ + + ][ + + ]: 9258 : if ( !strcmp( keyword, "body" ) || !strcmp( keyword, "Body" )) {
191 [ + - ][ + - ]: 5768 : CAST_LIST_TO_PARENT((*bodyList), entity_list) ;
[ + + ]
192 : : }
193 [ + + ][ + + ]: 7276 : else if ( !strcmp( keyword, "curve" ) || !strcmp( keyword, "Curve" ) ) {
194 [ + - ][ + - ]: 44970 : CAST_LIST_TO_PARENT((*refEdgeList), entity_list) ;
[ + + ]
195 : : }
196 [ + + ][ + + ]: 5304 : else if ( !strcmp( keyword, "volume" ) || !strcmp( keyword, "Volume" ) ) {
197 [ + - ][ + - ]: 3265 : CAST_LIST_TO_PARENT((*refVolumeList), entity_list) ;
[ + + ]
198 : : }
199 [ + + ][ + + ]: 4110 : else if ( !strcmp( keyword, "vertex" ) || !strcmp( keyword, "Vertex" ) ) {
200 [ + - ][ + - ]: 31956 : CAST_LIST_TO_PARENT((*refVertexList), entity_list) ;
[ + + ]
201 : : }
202 [ + + ][ + + ]: 2180 : else if ( !strcmp( keyword, "surface" ) || !strcmp( keyword, "Surface" ) ) {
203 [ + - ][ + - ]: 19252 : CAST_LIST_TO_PARENT((*refFaceList), entity_list) ;
[ + + ]
204 : : }
205 [ - + ][ # # ]: 220 : else if ( !strcmp( keyword, "group" ) || !strcmp( keyword, "Group" ) ) {
206 [ # # ][ - + ]: 220 : CAST_LIST_TO_PARENT((*refGroupList), entity_list) ;
207 : : }
208 : : else
209 : : {
210 [ # # ]: 0 : if (print_errors)
211 [ # # ]: 0 : PRINT_ERROR("Invalid list type for the ref_entity_list "
212 [ # # ]: 0 : "function: %s\n", keyword);
213 : 0 : return CUBIT_FAILURE;
214 : : }
215 : :
216 : 9258 : return CUBIT_SUCCESS;
217 : : }
218 : :
219 : 81482 : void RefEntityFactory::add(RefEntity* ref_entity)
220 : : {
221 [ - + ]: 81482 : assert(ref_entity != 0);
222 : :
223 : : RefGroup *group;
224 : : RefVolume *volume;
225 : : RefFace *face;
226 : : RefEdge *edge;
227 : : RefVertex *vertex;
228 : : Body *body;
229 : :
230 [ - + ][ + + ]: 81482 : if ( (group = CAST_TO(ref_entity, RefGroup)) != NULL ) {
231 : 140 : add(group);
232 : : }
233 [ - + ][ + + ]: 81342 : else if ( (volume = CAST_TO(ref_entity, RefVolume)) != NULL ) {
234 : 2846 : add(volume);
235 : : }
236 [ - + ][ + + ]: 78496 : else if ( (face = CAST_TO(ref_entity, RefFace)) != NULL ) {
237 : 16046 : add(face);
238 : : }
239 [ - + ][ + + ]: 62450 : else if ( (edge = CAST_TO(ref_entity, RefEdge)) != NULL ) {
240 : 35251 : add(edge);
241 : : }
242 [ - + ][ + + ]: 27199 : else if ( (vertex = CAST_TO(ref_entity, RefVertex)) != NULL ) {
243 : 24483 : add(vertex);
244 : : }
245 [ - + ][ + - ]: 2716 : else if ( (body = CAST_TO(ref_entity, Body)) != NULL ) {
246 : 2716 : add(body);
247 : : }
248 : 81482 : }
249 : :
250 : 140 : void RefEntityFactory::add(RefGroup* refGPtr)
251 : : {
252 [ - + ]: 140 : assert(!refGroupList->is_in_list(refGPtr));
253 [ + + ]: 140 : if(refGroupList->size() > 0)
254 : : {
255 : 87 : refGroupList->last();
256 [ + - ][ - + ]: 87 : if(ManageListSorting && refGPtr->id() < refGroupList->get()->id())
[ - + ]
257 : 0 : refGroupListIsSorted = false;
258 : : }
259 : 140 : refGroupList->append(refGPtr);
260 [ - + ]: 140 : if (refGPtr->id() > maxRefGroupId) maxRefGroupId = refGPtr->id();
261 : 140 : }
262 : :
263 : 2716 : void RefEntityFactory::add(Body* bodyPtr)
264 : : {
265 [ - + ]: 2716 : assert(!bodyList->is_in_list(bodyPtr));
266 [ + + ]: 2716 : if(bodyList->size() > 0)
267 : : {
268 : 1661 : bodyList->last();
269 [ + - ][ - + ]: 1661 : if(ManageListSorting && bodyPtr->id() < bodyList->get()->id())
[ - + ]
270 : 0 : bodyListIsSorted = false;
271 : : }
272 : 2716 : bodyList->append(bodyPtr);
273 [ - + ]: 2716 : if (bodyPtr->id() > maxBodyId) maxBodyId = bodyPtr->id();
274 : 2716 : }
275 : :
276 : 2846 : void RefEntityFactory::add(RefVolume* refVPtr)
277 : : {
278 [ - + ]: 2846 : assert(!refVolumeList->is_in_list(refVPtr));
279 [ + + ]: 2846 : if(refVolumeList->size() > 0)
280 : : {
281 : 1791 : refVolumeList->last();
282 [ + - ][ - + ]: 1791 : if(ManageListSorting && refVPtr->id() < refVolumeList->get()->id())
[ - + ]
283 : 0 : refVolumeListIsSorted = false;
284 : : }
285 : 2846 : refVolumeList->append(refVPtr);
286 [ - + ]: 2846 : if (refVPtr->id() > maxRefVolumeId)
287 : 0 : maxRefVolumeId = refVPtr->id();
288 : 2846 : }
289 : :
290 : 16046 : void RefEntityFactory::add(RefFace* refFPtr)
291 : : {
292 [ - + ]: 16046 : assert(!refFaceList->is_in_list(refFPtr));
293 [ + + ]: 16046 : if(refFaceList->size() > 0)
294 : : {
295 : 15013 : refFaceList->last();
296 [ + - ][ + + ]: 15013 : if(ManageListSorting && refFPtr->id() < refFaceList->get()->id())
[ + + ]
297 : 40 : refFaceListIsSorted = false;
298 : : }
299 : 16046 : refFaceList->append(refFPtr);
300 [ - + ]: 16046 : if (refFPtr->entityId > maxRefFaceId)
301 : 0 : maxRefFaceId = refFPtr->entityId;
302 : 16046 : }
303 : :
304 : 35251 : void RefEntityFactory::add(RefEdge* refEPtr)
305 : : {
306 [ - + ]: 35251 : assert(!refEdgeList->is_in_list(refEPtr));
307 [ + + ]: 35251 : if(refEdgeList->size() > 0)
308 : : {
309 : 34174 : refEdgeList->last();
310 [ + - ][ + + ]: 34174 : if(ManageListSorting && refEPtr->id() < refEdgeList->get()->id())
[ + + ]
311 : 72 : refEdgeListIsSorted = false;
312 : : }
313 : 35251 : refEdgeList->append(refEPtr);
314 [ - + ]: 35251 : if (refEPtr->id() > maxRefEdgeId)
315 : 0 : maxRefEdgeId = refEPtr->id();
316 : 35251 : }
317 : :
318 : 24483 : void RefEntityFactory::add(RefVertex* refVPtr)
319 : : {
320 [ - + ]: 24483 : assert(!refVertexList->is_in_list(refVPtr));
321 [ + + ]: 24483 : if(refVertexList->size() > 0)
322 : : {
323 : 23417 : refVertexList->last();
324 [ + - ][ + + ]: 23417 : if(ManageListSorting && refVPtr->id() < refVertexList->get()->id())
[ + + ]
325 : 10 : refVertexListIsSorted = false;
326 : : }
327 : 24483 : refVertexList->append(refVPtr);
328 [ - + ]: 24483 : if (refVPtr->id() > maxRefVertexId)
329 : 0 : maxRefVertexId = refVPtr->id();
330 : 24483 : }
331 : :
332 : :
333 : 50333 : void RefEntityFactory::remove(RefEntity* ref_entity)
334 : : {
335 [ - + ]: 50333 : assert(ref_entity != 0);
336 : :
337 : : RefGroup *group;
338 : : RefVolume *volume;
339 : : RefFace *face;
340 : : RefEdge *edge;
341 : : RefVertex *vertex;
342 : : Body *body;
343 : :
344 [ - + ][ + + ]: 50333 : if ( (group = CAST_TO(ref_entity, RefGroup)) != NULL ) {
345 : 99 : remove(group);
346 : : }
347 [ - + ][ + + ]: 50234 : else if ( (volume = CAST_TO(ref_entity, RefVolume)) != NULL ) {
348 : 1679 : remove(volume);
349 : : }
350 [ - + ][ + + ]: 48555 : else if ( (face = CAST_TO(ref_entity, RefFace)) != NULL ) {
351 : 9920 : remove(face);
352 : : }
353 [ - + ][ + + ]: 38635 : else if ( (edge = CAST_TO(ref_entity, RefEdge)) != NULL ) {
354 : 21863 : remove(edge);
355 : : }
356 [ - + ][ + + ]: 16772 : else if ( (vertex = CAST_TO(ref_entity, RefVertex)) != NULL ) {
357 : 15223 : remove(vertex);
358 : : }
359 [ - + ][ + - ]: 1549 : else if ( (body = CAST_TO(ref_entity, Body)) != NULL ) {
360 : 1549 : remove(body);
361 : : }
362 : 50333 : }
363 : :
364 : 15223 : void RefEntityFactory::remove (RefVertex *ref_vertex_ptr)
365 : : {
366 [ - + ]: 15223 : if (!refVertexList) return;
367 : :
368 [ + - ]: 15223 : if (ref_vertex_ptr != NULL)
369 : : {
370 [ + - ]: 15223 : if (refVertexList->move_to ( ref_vertex_ptr ))
371 : 15223 : refVertexList->remove ();
372 : 0 : else assert(0);
373 : : }
374 : : }
375 : :
376 : 21863 : void RefEntityFactory::remove (RefEdge *ref_edge_ptr)
377 : : {
378 [ - + ]: 21863 : if (!refEdgeList) return;
379 : :
380 [ + - ]: 21863 : if (ref_edge_ptr != NULL)
381 : : {
382 [ + - ]: 21863 : if (refEdgeList->move_to ( ref_edge_ptr ))
383 : 21863 : refEdgeList->remove ();
384 : 0 : else assert(0);
385 : : }
386 : : }
387 : :
388 : 9920 : void RefEntityFactory::remove (RefFace *ref_face_ptr)
389 : : {
390 [ - + ]: 9920 : if (!refFaceList) return;
391 : :
392 [ + - ]: 9920 : if (ref_face_ptr != NULL)
393 : : {
394 [ + - ]: 9920 : if (refFaceList->move_to ( ref_face_ptr ))
395 : 9920 : refFaceList->remove ();
396 : 0 : else assert(0);
397 : : }
398 : : }
399 : :
400 : 1679 : void RefEntityFactory::remove (RefVolume *ref_volume_ptr)
401 : : {
402 [ - + ]: 1679 : if (!refVolumeList) return;
403 : :
404 [ + - ]: 1679 : if (ref_volume_ptr != NULL)
405 : : {
406 [ + - ]: 1679 : if (refVolumeList->move_to ( ref_volume_ptr ))
407 : 1679 : refVolumeList->remove ();
408 : 0 : else assert(0);
409 : : }
410 : : }
411 : :
412 : 99 : void RefEntityFactory::remove (RefGroup *ref_group_ptr)
413 : : {
414 [ - + ]: 99 : if (!refGroupList) return;
415 : :
416 [ + - ]: 99 : if (ref_group_ptr != NULL)
417 : : {
418 [ + - ]: 99 : if (refGroupList->move_to ( ref_group_ptr ))
419 : 99 : refGroupList->remove ();
420 : 0 : else assert(0);
421 : : }
422 : : }
423 : :
424 : 1549 : void RefEntityFactory::remove (Body *body_ptr)
425 : : {
426 [ - + ]: 1549 : if (!bodyList) return;
427 : :
428 [ + - ]: 1549 : if (body_ptr != NULL)
429 : : {
430 [ + - ]: 1549 : if (bodyList->move_to ( body_ptr ))
431 : 1549 : bodyList->remove ();
432 : 0 : else assert(0);
433 : : }
434 : : }
435 : :
436 : 419 : void RefEntityFactory::bodies(DLIList<Body*> &bodies)
437 : : {
438 : 419 : bodies = *bodyList;
439 : 419 : }
440 : :
441 : 0 : void RefEntityFactory::ref_volumes(DLIList<RefVolume*> &ref_volumes)
442 : : {
443 : 0 : ref_volumes = *refVolumeList;
444 : 0 : }
445 : :
446 : 877 : void RefEntityFactory::ref_groups(DLIList<RefGroup*> &ref_groups)
447 : : {
448 : 877 : ref_groups = *refGroupList;
449 : 877 : }
450 : :
451 : 33 : void RefEntityFactory::ref_faces(DLIList<RefFace*> &ref_faces)
452 : : {
453 : 33 : ref_faces = *refFaceList;
454 : 33 : }
455 : :
456 : 77 : void RefEntityFactory::ref_edges(DLIList<RefEdge*> &ref_edges)
457 : : {
458 : 77 : ref_edges = *refEdgeList;
459 : 77 : }
460 : :
461 : 22 : void RefEntityFactory::ref_vertices(DLIList<RefVertex*> &ref_vertices)
462 : : {
463 : 22 : ref_vertices = *refVertexList;
464 : 22 : }
465 : :
466 : : #ifdef PROE
467 : : void RefEntityFactory::ref_parts(DLIList<RefPart*> &ref_parts)
468 : : {
469 : : ref_parts = *refPartList;
470 : : }
471 : :
472 : : void RefEntityFactory::ref_assemblies(DLIList<RefAssembly*> &ref_assemblies)
473 : : {
474 : : ref_assemblies = *refAssemblyList;
475 : : }
476 : : #endif
477 : :
478 : 2936 : int RefEntityFactory::num_bodies() const {return bodyList->size();}
479 : 2178 : int RefEntityFactory::num_ref_volumes() const {return refVolumeList->size();}
480 : 1024 : int RefEntityFactory::num_ref_groups() const {return refGroupList->size();}
481 : 3706 : int RefEntityFactory::num_ref_faces() const {return refFaceList->size();}
482 : 3706 : int RefEntityFactory::num_ref_edges() const {return refEdgeList->size();}
483 : 3706 : int RefEntityFactory::num_ref_vertices() const {return refVertexList->size();}
484 : :
485 : 5288 : RefEntity* RefEntityFactory::get_ref_entity(const char *type_string, int id)
486 : : {
487 : : // Call the right function, cast it.
488 [ + + + + : 5288 : switch( toupper(*type_string) )
- - ]
489 : : {
490 : : case 'B':
491 [ + - ]: 206 : if( !strcmp(type_string+1,"ody") )
492 [ + + ]: 206 : return get_body(id);
493 : 0 : break;
494 : : case 'V':
495 [ + + ]: 1470 : if( !strcmp(type_string+1,"olume" ) )
496 [ + - ]: 110 : return get_ref_volume(id);
497 [ + - ]: 1360 : else if(!strcmp(type_string+1,"ertex") )
498 [ + + ]: 1360 : return get_ref_vertex(id);
499 : 0 : break;
500 : : case 'S':
501 [ + - ]: 1300 : if( !strcmp(type_string+1,"urface") )
502 [ + + ]: 1300 : return get_ref_face(id);
503 : 0 : break;
504 : : case 'C':
505 [ + - ]: 2312 : if( !strcmp(type_string+1,"urve") )
506 [ + + ]: 2312 : return get_ref_edge(id);
507 : 0 : break;
508 : : case 'G':
509 [ # # ]: 0 : if( !strcmp(type_string+1,"roup") )
510 : 0 : return get_ref_group(id);
511 : 0 : break;
512 : : }
513 : :
514 [ # # ]: 0 : PRINT_ERROR("Invalid list type for the get_ref_entity "
515 [ # # ]: 0 : "function: %s\n", type_string);
516 : 5288 : return NULL;
517 : : }
518 : : //_________ Add Code by DZ of Cat, 3/17/99 11:24:22 AM _________
519 : 0 : RefEntity* RefEntityFactory::get_ref_entity (const std::type_info& type, int id)
520 : : {
521 : : // Call the right function, cast it.
522 [ # # ]: 0 : if( type == typeid(RefGroup) )
523 : 0 : return CAST_TO(get_ref_group(id), RefEntity);
524 [ # # ]: 0 : else if( type == typeid(Body) )
525 [ # # ]: 0 : return CAST_TO(get_body(id), RefEntity);
526 [ # # ]: 0 : else if( type == typeid(RefVolume) )
527 [ # # ]: 0 : return CAST_TO(get_ref_volume(id), RefEntity);
528 [ # # ]: 0 : else if( type == typeid(RefFace) )
529 [ # # ]: 0 : return CAST_TO(get_ref_face(id), RefEntity);
530 [ # # ]: 0 : else if( type == typeid(RefEdge) )
531 [ # # ]: 0 : return CAST_TO(get_ref_edge(id), RefEntity);
532 [ # # ]: 0 : else if( type == typeid(RefVertex) )
533 [ # # ]: 0 : return CAST_TO(get_ref_vertex(id), RefEntity);
534 : :
535 : 0 : return NULL;
536 : : }
537 : : //_________ Code End by DZ of Cat, 3/17/99 11:24:22 AM _________
538 : :
539 : 294 : Body* RefEntityFactory::get_body (int id)
540 : : {
541 [ + + ]: 294 : if (!bodyList->size())
542 : 10 : return NULL;
543 : :
544 : : // Make sure the list is sorted for the binary search.
545 [ + - ][ + + ]: 284 : if(ManageListSorting && !bodyListIsSorted)
546 : : {
547 : 55 : bodyList->sort(sort_by_ascending_ids);
548 : 55 : bodyListIsSorted = true;
549 : : }
550 : :
551 : : // Do a binary search on the sorted list. We are making the assumption
552 : : // here that there are no NULL entries in the list.
553 : 284 : bool found = false;
554 : 284 : int left_index = 0;
555 : 284 : int right_index = bodyList->size()-1;
556 : 284 : int mid_index = (left_index + right_index)/2;
557 : 284 : int mid_id = ((*bodyList)[mid_index])->id();
558 : :
559 [ + + ][ + + ]: 800 : while(!found && (right_index-left_index) > 1)
560 : : {
561 [ + + ]: 516 : if(mid_id == id)
562 : 99 : found = true;
563 : : else
564 : : {
565 [ + + ]: 417 : if(mid_id > id)
566 : 66 : right_index = mid_index;
567 : : else
568 : 351 : left_index = mid_index;
569 : 417 : mid_index = (left_index + right_index)/2;
570 : 417 : mid_id = ((*bodyList)[mid_index])->id();
571 : : }
572 : : }
573 : :
574 [ + + ]: 284 : if(!found)
575 : : {
576 [ + + ]: 185 : if(((*bodyList)[left_index])->id() == id)
577 : 88 : return ((*bodyList)[left_index]);
578 [ + + ]: 97 : else if(((*bodyList)[right_index])->id() == id)
579 : 11 : return ((*bodyList)[right_index]);
580 : : }
581 : : else
582 : 99 : return ((*bodyList)[mid_index]);
583 : :
584 : 86 : return NULL ;
585 : : }
586 : :
587 : 0 : RefGroup* RefEntityFactory::get_ref_group (int id)
588 : : {
589 [ # # ]: 0 : if (!refGroupList->size())
590 : 0 : return NULL;
591 : :
592 : : // Make sure the list is sorted for the binary search.
593 [ # # ][ # # ]: 0 : if(ManageListSorting && !refGroupListIsSorted)
594 : : {
595 : 0 : refGroupList->sort(sort_by_ascending_ids);
596 : 0 : refGroupListIsSorted = true;
597 : : }
598 : :
599 : : // Do a binary search on the sorted list. We are making the assumption
600 : : // here that there are no NULL entries in the list.
601 : 0 : bool found = false;
602 : 0 : int left_index = 0;
603 : 0 : int right_index = refGroupList->size()-1;
604 : 0 : int mid_index = (left_index + right_index)/2;
605 : 0 : int mid_id = ((*refGroupList)[mid_index])->id();
606 : :
607 [ # # ][ # # ]: 0 : while(!found && (right_index-left_index) > 1)
608 : : {
609 [ # # ]: 0 : if(mid_id == id)
610 : 0 : found = true;
611 : : else
612 : : {
613 [ # # ]: 0 : if(mid_id > id)
614 : 0 : right_index = mid_index;
615 : : else
616 : 0 : left_index = mid_index;
617 : 0 : mid_index = (left_index + right_index)/2;
618 : 0 : mid_id = ((*refGroupList)[mid_index])->id();
619 : : }
620 : : }
621 : :
622 [ # # ]: 0 : if(!found)
623 : : {
624 [ # # ]: 0 : if(((*refGroupList)[left_index])->id() == id)
625 : 0 : return ((*refGroupList)[left_index]);
626 [ # # ]: 0 : else if(((*refGroupList)[right_index])->id() == id)
627 : 0 : return ((*refGroupList)[right_index]);
628 : : }
629 : : else
630 : 0 : return ((*refGroupList)[mid_index]);
631 : :
632 : 0 : return NULL ;
633 : : }
634 : :
635 : 110 : RefVolume* RefEntityFactory::get_ref_volume (int id)
636 : : {
637 [ - + ]: 110 : if (!refVolumeList->size())
638 : 0 : return NULL;
639 : :
640 : : // Make sure the list is sorted for the binary search.
641 [ + - ][ - + ]: 110 : if(ManageListSorting && !refVolumeListIsSorted)
642 : : {
643 : 0 : refVolumeList->sort(sort_by_ascending_ids);
644 : 0 : refVolumeListIsSorted = true;
645 : : }
646 : :
647 : : // Do a binary search on the sorted list. We are making the assumption
648 : : // here that there are no NULL entries in the list.
649 : 110 : bool found = false;
650 : 110 : int left_index = 0;
651 : 110 : int right_index = refVolumeList->size()-1;
652 : 110 : int mid_index = (left_index + right_index)/2;
653 : 110 : int mid_id = ((*refVolumeList)[mid_index])->id();
654 : :
655 [ + + ][ + + ]: 209 : while(!found && (right_index-left_index) > 1)
656 : : {
657 [ + + ]: 99 : if(mid_id == id)
658 : 55 : found = true;
659 : : else
660 : : {
661 [ + - ]: 44 : if(mid_id > id)
662 : 44 : right_index = mid_index;
663 : : else
664 : 0 : left_index = mid_index;
665 : 44 : mid_index = (left_index + right_index)/2;
666 : 44 : mid_id = ((*refVolumeList)[mid_index])->id();
667 : : }
668 : : }
669 : :
670 [ + + ]: 110 : if(!found)
671 : : {
672 [ + - ]: 55 : if(((*refVolumeList)[left_index])->id() == id)
673 : 55 : return ((*refVolumeList)[left_index]);
674 [ # # ]: 0 : else if(((*refVolumeList)[right_index])->id() == id)
675 : 0 : return ((*refVolumeList)[right_index]);
676 : : }
677 : : else
678 : 55 : return ((*refVolumeList)[mid_index]);
679 : :
680 : 0 : return NULL ;
681 : : }
682 : :
683 : 1300 : RefFace* RefEntityFactory::get_ref_face (int id)
684 : : {
685 [ + + ]: 1300 : if (!refFaceList->size())
686 : 10 : return NULL;
687 : :
688 : : // Make sure the list is sorted for the binary search.
689 [ + - ][ + + ]: 1290 : if(ManageListSorting && !refFaceListIsSorted)
690 : : {
691 : 30 : refFaceList->sort(sort_by_ascending_ids);
692 : 30 : refFaceListIsSorted = true;
693 : : }
694 : :
695 : : // Do a binary search on the sorted list. We are making the assumption
696 : : // here that there are no NULL entries in the list.
697 : 1290 : bool found = false;
698 : 1290 : int left_index = 0;
699 : 1290 : int right_index = refFaceList->size()-1;
700 : 1290 : int mid_index = (left_index + right_index)/2;
701 : 1290 : int mid_id = ((*refFaceList)[mid_index])->id();
702 : :
703 [ + + ][ + + ]: 5608 : while(!found && (right_index-left_index) > 1)
704 : : {
705 [ + + ]: 4318 : if(mid_id == id)
706 : 1100 : found = true;
707 : : else
708 : : {
709 [ + + ]: 3218 : if(mid_id > id)
710 : 2000 : right_index = mid_index;
711 : : else
712 : 1218 : left_index = mid_index;
713 : 3218 : mid_index = (left_index + right_index)/2;
714 : 3218 : mid_id = ((*refFaceList)[mid_index])->id();
715 : : }
716 : : }
717 : :
718 [ + + ]: 1290 : if(!found)
719 : : {
720 [ + + ]: 190 : if(((*refFaceList)[left_index])->id() == id)
721 : 110 : return ((*refFaceList)[left_index]);
722 [ - + ]: 80 : else if(((*refFaceList)[right_index])->id() == id)
723 : 0 : return ((*refFaceList)[right_index]);
724 : : }
725 : : else
726 : 1100 : return ((*refFaceList)[mid_index]);
727 : :
728 : 80 : return NULL ;
729 : : }
730 : :
731 : 2312 : RefEdge* RefEntityFactory::get_ref_edge (int id)
732 : : {
733 [ + + ]: 2312 : if (!refEdgeList->size())
734 : 10 : return NULL;
735 : :
736 : : // Make sure the list is sorted for the binary search.
737 [ + - ][ + + ]: 2302 : if(ManageListSorting && !refEdgeListIsSorted)
738 : : {
739 : 51 : refEdgeList->sort(sort_by_ascending_ids);
740 : 51 : refEdgeListIsSorted = true;
741 : : }
742 : :
743 : : // Do a binary search on the sorted list. We are making the assumption
744 : : // here that there are no NULL entries in the list.
745 : 2302 : bool found = false;
746 : 2302 : int left_index = 0;
747 : 2302 : int right_index = refEdgeList->size()-1;
748 : 2302 : int mid_index = (left_index + right_index)/2;
749 : 2302 : int mid_id = ((*refEdgeList)[mid_index])->id();
750 : :
751 [ + + ][ + + ]: 12154 : while(!found && (right_index-left_index) > 1)
752 : : {
753 [ + + ]: 9852 : if(mid_id == id)
754 : 2112 : found = true;
755 : : else
756 : : {
757 [ + + ]: 7740 : if(mid_id > id)
758 : 4524 : right_index = mid_index;
759 : : else
760 : 3216 : left_index = mid_index;
761 : 7740 : mid_index = (left_index + right_index)/2;
762 : 7740 : mid_id = ((*refEdgeList)[mid_index])->id();
763 : : }
764 : : }
765 : :
766 [ + + ]: 2302 : if(!found)
767 : : {
768 [ + + ]: 190 : if(((*refEdgeList)[left_index])->id() == id)
769 : 110 : return ((*refEdgeList)[left_index]);
770 [ - + ]: 80 : else if(((*refEdgeList)[right_index])->id() == id)
771 : 0 : return ((*refEdgeList)[right_index]);
772 : : }
773 : : else
774 : 2112 : return ((*refEdgeList)[mid_index]);
775 : :
776 : 80 : return NULL ;
777 : : }
778 : :
779 : 1360 : RefVertex* RefEntityFactory::get_ref_vertex (int id)
780 : : {
781 [ + + ]: 1360 : if (!refVertexList->size())
782 : 10 : return NULL;
783 : :
784 : : // Make sure the list is sorted for the binary search.
785 [ + - ][ - + ]: 1350 : if(ManageListSorting && !refVertexListIsSorted)
786 : : {
787 : 0 : refVertexList->sort(sort_by_ascending_ids);
788 : 0 : refVertexListIsSorted = true;
789 : : }
790 : :
791 : : // Do a binary search on the sorted list. We are making the assumption
792 : : // here that there are no NULL entries in the list.
793 : 1350 : bool found = false;
794 : 1350 : int left_index = 0;
795 : 1350 : int right_index = refVertexList->size()-1;
796 : 1350 : int mid_index = (left_index + right_index)/2;
797 : 1350 : int mid_id = ((*refVertexList)[mid_index])->id();
798 : :
799 [ + + ][ + + ]: 6170 : while(!found && (right_index-left_index) > 1)
800 : : {
801 [ + + ]: 4820 : if(mid_id == id)
802 : 1210 : found = true;
803 : : else
804 : : {
805 [ + + ]: 3610 : if(mid_id > id)
806 : 2220 : right_index = mid_index;
807 : : else
808 : 1390 : left_index = mid_index;
809 : 3610 : mid_index = (left_index + right_index)/2;
810 : 3610 : mid_id = ((*refVertexList)[mid_index])->id();
811 : : }
812 : : }
813 : :
814 [ + + ]: 1350 : if(!found)
815 : : {
816 [ + + ]: 140 : if(((*refVertexList)[left_index])->id() == id)
817 : 110 : return ((*refVertexList)[left_index]);
818 [ - + ]: 30 : else if(((*refVertexList)[right_index])->id() == id)
819 : 0 : return ((*refVertexList)[right_index]);
820 : : }
821 : : else
822 : 1210 : return ((*refVertexList)[mid_index]);
823 : :
824 : 30 : return NULL ;
825 : : }
826 : :
827 : : //* Methods: next*Id
828 : : //** Increments the maximum object ID and returns this value.
829 : : //==
830 : 2716 : int RefEntityFactory::next_body_id ()
831 : : {
832 : 2716 : return ++maxBodyId;
833 : : }
834 : :
835 : 140 : int RefEntityFactory::next_ref_group_id ()
836 : : {
837 : 140 : return ++maxRefGroupId;
838 : : }
839 : :
840 : 2846 : int RefEntityFactory::next_ref_volume_id ()
841 : : {
842 : 2846 : return ++maxRefVolumeId;
843 : : }
844 : :
845 : 16046 : int RefEntityFactory::next_ref_face_id ()
846 : : {
847 : 16046 : return ++maxRefFaceId;
848 : : }
849 : :
850 : 35251 : int RefEntityFactory::next_ref_edge_id ()
851 : : {
852 : 35251 : return ++maxRefEdgeId;
853 : : }
854 : :
855 : 24483 : int RefEntityFactory::next_ref_vertex_id ()
856 : : {
857 : 24483 : return ++maxRefVertexId;
858 : : }
859 : :
860 : : #ifdef PROE
861 : : int RefEntityFactory::next_ref_assembly_id ()
862 : : {
863 : : return ++maxRefAssemblyId;
864 : : }
865 : :
866 : : int RefEntityFactory::next_ref_part_id ()
867 : : {
868 : : return ++maxRefPartId;
869 : : }
870 : : #endif
871 : :
872 : 0 : Body *RefEntityFactory::get_first_body()
873 : : {
874 : 0 : bodyList->reset();
875 [ # # ]: 0 : return bodyList->size() ? bodyList->get() : 0;
876 : : }
877 : :
878 : 0 : RefVolume *RefEntityFactory::get_first_ref_volume()
879 : : {
880 : 0 : refVolumeList->reset();
881 [ # # ]: 0 : return refVolumeList->size() ? refVolumeList->get() : 0;
882 : : }
883 : :
884 : 0 : RefGroup *RefEntityFactory::get_first_ref_group()
885 : : {
886 : 0 : refGroupList->reset();
887 [ # # ]: 0 : return refGroupList->size() ? refGroupList->get() : 0;
888 : : }
889 : :
890 : 0 : RefFace *RefEntityFactory::get_first_ref_face()
891 : : {
892 : 0 : refFaceList->reset();
893 [ # # ]: 0 : return refFaceList->size() ? refFaceList->get() : 0;
894 : : }
895 : :
896 : 0 : RefEdge *RefEntityFactory::get_first_ref_edge()
897 : : {
898 : 0 : refEdgeList->reset();
899 [ # # ]: 0 : return refEdgeList->size() ? refEdgeList->get() : 0;
900 : : }
901 : :
902 : 0 : RefVertex *RefEntityFactory::get_first_ref_vertex()
903 : : {
904 : 0 : refVertexList->reset();
905 [ # # ]: 0 : return refVertexList->size() ? refVertexList->get() : 0;
906 : : }
907 : :
908 : :
909 : 771 : Body *RefEntityFactory::get_next_body()
910 [ + - ]: 771 : {return bodyList->size() ? bodyList->step_and_get() : 0;}
911 : :
912 : 1608 : RefVolume *RefEntityFactory::get_next_ref_volume()
913 [ + - ]: 1608 : {return refVolumeList->size() ? refVolumeList->step_and_get() : 0;}
914 : :
915 : 0 : RefGroup *RefEntityFactory::get_next_ref_group()
916 [ # # ]: 0 : {return refGroupList->size() ? refGroupList->step_and_get() : 0;}
917 : :
918 : 9326 : RefFace *RefEntityFactory::get_next_ref_face()
919 [ + - ]: 9326 : {return refFaceList->size() ? refFaceList->step_and_get() : 0;}
920 : :
921 : 23936 : RefEdge *RefEntityFactory::get_next_ref_edge()
922 [ + - ]: 23936 : {return refEdgeList->size() ? refEdgeList->step_and_get() : 0;}
923 : :
924 : 18816 : RefVertex *RefEntityFactory::get_next_ref_vertex()
925 [ + - ]: 18816 : {return refVertexList->size() ? refVertexList->step_and_get() : 0;}
926 : :
927 : 780 : Body *RefEntityFactory::get_last_body()
928 : : {
929 : 780 : bodyList->last();
930 [ + + ]: 780 : return bodyList->size() ? bodyList->get() : 0;
931 : : }
932 : :
933 : 0 : RefVolume *RefEntityFactory::get_last_ref_volume()
934 : : {
935 : 0 : refVolumeList->last();
936 [ # # ]: 0 : return refVolumeList->size() ? refVolumeList->get() : 0;
937 : : }
938 : :
939 : 11 : RefGroup *RefEntityFactory::get_last_ref_group()
940 : : {
941 : 11 : refGroupList->last();
942 [ - + ]: 11 : return refGroupList->size() ? refGroupList->get() : 0;
943 : : }
944 : :
945 : 332 : RefFace *RefEntityFactory::get_last_ref_face()
946 : : {
947 : 332 : refFaceList->last();
948 [ - + ]: 332 : return refFaceList->size() ? refFaceList->get() : 0;
949 : : }
950 : :
951 : 354 : RefEdge *RefEntityFactory::get_last_ref_edge()
952 : : {
953 : 354 : refEdgeList->last();
954 [ + + ]: 354 : return refEdgeList->size() ? refEdgeList->get() : 0;
955 : : }
956 : :
957 : 343 : RefVertex *RefEntityFactory::get_last_ref_vertex()
958 : : {
959 : 343 : refVertexList->last();
960 [ + + ]: 343 : return refVertexList->size() ? refVertexList->get() : 0;
961 : : }
962 : :
963 : 227 : void RefEntityFactory::incorporate_id (RefEntity *ref_ent)
964 : : {
965 [ + - ]: 227 : if (ref_ent)
966 : : {
967 : : //________ Change Code by DZ of Cat, 3/17/99 10:47:39 AM ________
968 : 227 : int max_ent_id = 0;
969 : :
970 : 227 : max_ent_id = ref_ent->id();
971 : : // Do nothing with groups
972 [ + - ][ + + ]: 227 : if( CAST_TO( ref_ent, RefGroup ) ) {
[ + + ]
973 [ + - ]: 11 : if (maxRefGroupId < max_ent_id)
974 : 11 : maxRefGroupId = max_ent_id;
975 : : }
976 [ + - ][ + + ]: 216 : else if( CAST_TO( ref_ent, Body ) )
[ + + ]
977 : : {
978 [ + - ]: 96 : if (maxBodyId < max_ent_id)
979 : 96 : maxBodyId = max_ent_id;
980 : : }
981 [ + - ][ - + ]: 120 : else if( CAST_TO( ref_ent, RefVolume ) )
[ - + ]
982 : : {
983 [ # # ]: 0 : if (maxRefVolumeId < max_ent_id)
984 : 0 : maxRefVolumeId = max_ent_id;
985 : : }
986 [ + - ][ + + ]: 120 : else if( CAST_TO( ref_ent, RefFace ) )
[ + + ]
987 : : {
988 [ + - ]: 50 : if (maxRefFaceId < max_ent_id)
989 : 50 : maxRefFaceId = max_ent_id;
990 : : }
991 [ + - ][ + + ]: 70 : else if( CAST_TO( ref_ent, RefEdge ) )
[ + + ]
992 : : {
993 [ + - ]: 40 : if (maxRefEdgeId < max_ent_id)
994 : 40 : maxRefEdgeId = max_ent_id;
995 : : }
996 [ + - ][ + - ]: 30 : else if( CAST_TO( ref_ent, RefVertex ) )
[ + - ]
997 : : {
998 [ + - ]: 30 : if (maxRefVertexId < max_ent_id)
999 : 227 : maxRefVertexId = max_ent_id;
1000 : : }
1001 : : //________ Change End by DZ of Cat, 3/17/99 10:47:39 AM ________
1002 : : }
1003 : 227 : }
1004 : :
1005 : 0 : int RefEntityFactory::maximum_id(const char *entity_type)
1006 : : {
1007 [ # # ]: 0 : if (strcmp("body", entity_type) == 0)
1008 : 0 : return maxBodyId;
1009 [ # # ]: 0 : else if (strcmp("curve", entity_type) == 0)
1010 : 0 : return maxRefEdgeId;
1011 [ # # ]: 0 : else if (strcmp("group", entity_type) == 0)
1012 : 0 : return maxRefGroupId;
1013 [ # # ]: 0 : else if (strcmp("volume", entity_type) == 0)
1014 : 0 : return maxRefVolumeId;
1015 [ # # ]: 0 : else if (strcmp("vertex", entity_type) == 0)
1016 : 0 : return maxRefVertexId;
1017 [ # # ]: 0 : else if (strcmp("surface", entity_type) == 0)
1018 : 0 : return maxRefFaceId;
1019 : : else {
1020 [ # # ][ # # ]: 0 : PRINT_ERROR("Unrecognized entity_type: '%s'\n", entity_type);
1021 : 0 : return 0;
1022 : : }
1023 : : }
1024 : :
1025 : 133 : void RefEntityFactory::maximum_id (const std::type_info& type, int max_id)
1026 : : {
1027 [ + + ]: 133 : if( type == typeid(RefGroup) )
1028 : 11 : maxRefGroupId = max_id;
1029 [ - + ]: 122 : else if( type == typeid(Body) )
1030 : 0 : maxBodyId = max_id;
1031 [ - + ]: 122 : else if( type == typeid(RefVolume) )
1032 : 0 : maxRefVolumeId = max_id;
1033 [ + + ]: 122 : else if( type == typeid(RefFace) )
1034 : 40 : maxRefFaceId = max_id;
1035 [ + + ]: 82 : else if( type == typeid(RefEdge) )
1036 : 72 : maxRefEdgeId = max_id;
1037 [ + - ]: 10 : else if( type == typeid(RefVertex) )
1038 : 10 : maxRefVertexId = max_id;
1039 : 133 : }
1040 : :
1041 : 360 : int RefEntityFactory::maximum_id (RefEntity *ref_ent)
1042 : : {
1043 [ - + ]: 360 : if (!ref_ent)
1044 : 0 : return 0;
1045 [ + - ][ + + ]: 360 : else if( CAST_TO( ref_ent, RefGroup ) )
[ + + ]
1046 : 22 : return maxRefGroupId;
1047 [ + - ][ + + ]: 338 : else if( CAST_TO( ref_ent, Body ) )
[ + + ]
1048 : 96 : return maxBodyId;
1049 [ + - ][ - + ]: 242 : else if( CAST_TO( ref_ent, RefVolume ) )
[ - + ]
1050 : 0 : return maxRefVolumeId;
1051 [ + - ][ + + ]: 242 : else if( CAST_TO( ref_ent, RefFace ) )
[ + + ]
1052 : 90 : return maxRefFaceId;
1053 [ + - ][ + + ]: 152 : else if( CAST_TO( ref_ent, RefEdge ) )
[ + + ]
1054 : 112 : return maxRefEdgeId;
1055 [ + - ][ + - ]: 40 : else if( CAST_TO( ref_ent, RefVertex ) )
[ + - ]
1056 : 40 : return maxRefVertexId;
1057 : : else
1058 : 0 : return 0;
1059 : : }
1060 : :
1061 : 0 : void RefEntityFactory::compress_ref_ids(const char *entity_type, int retain_max_id)
1062 : : {
1063 [ # # ]: 0 : const std::type_info& type = RefEntity::get_entity_type_info(entity_type);
1064 [ # # ][ # # ]: 0 : assert(type != typeid(InvalidEntity));
1065 : :
1066 : : /*
1067 : : #ifdef VIRTUAL_GEOMETRY_ENGINE_HPP
1068 : : VirtualGeometryEngine::instance()->
1069 : : hidden_entity_mngr.compress_hidden_ids(type);
1070 : : #endif
1071 : : */
1072 : : /*
1073 : : DLIList<GeometryQueryEngine*> gqeList;
1074 : : GeometryQueryTool::instance()->get_gqe_list(gqeList);//Get the gqeList from the GQT
1075 : : gqeList.reset();
1076 : : int i;
1077 : : for (i = 0; i < gqeList.size(); i++)//Step through the list and call compress_ids.
1078 : : { //The VGE is the only engine that will do work.
1079 : : gqeList.get_and_step()->compress_ids(type);
1080 : : }
1081 : : */
1082 : :
1083 [ # # ]: 0 : DLIList<CubitEntity*> list;
1084 [ # # ][ # # ]: 0 : DLIList<RefEntity*> temp_list;
1085 [ # # ]: 0 : CubitStatus result = ref_entity_list(entity_type, temp_list, CUBIT_FALSE);
1086 [ # # ]: 0 : if ( result == CUBIT_SUCCESS ) {
1087 [ # # ][ # # ]: 0 : CAST_LIST_TO_PARENT(temp_list, list);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
1088 [ # # ]: 0 : compress_ids(list);
1089 : : }
1090 : :
1091 : : // set the maximum entity id to the new max values.
1092 [ # # ]: 0 : if (!retain_max_id)
1093 : : {
1094 : : // must use the num_xxx() functions here, since we may have a derived factory!
1095 [ # # ][ # # ]: 0 : if( type == typeid(RefGroup) )
1096 [ # # ]: 0 : maxRefGroupId = num_ref_groups();
1097 [ # # ][ # # ]: 0 : else if( type == typeid(Body) )
1098 [ # # ]: 0 : maxBodyId = num_bodies();
1099 [ # # ][ # # ]: 0 : else if( type == typeid(RefVolume) )
1100 [ # # ]: 0 : maxRefVolumeId = num_ref_volumes();
1101 [ # # ][ # # ]: 0 : else if( type == typeid(RefFace) )
1102 [ # # ]: 0 : maxRefFaceId = num_ref_faces();
1103 [ # # ][ # # ]: 0 : else if( type == typeid(RefEdge) )
1104 [ # # ]: 0 : maxRefEdgeId = num_ref_edges();
1105 [ # # ][ # # ]: 0 : else if( type == typeid(RefVertex) )
1106 [ # # ]: 0 : maxRefVertexId = num_ref_vertices();
1107 [ # # ]: 0 : }
1108 : 0 : }
1109 : :
1110 : 0 : void RefEntityFactory::compress_ids(DLIList<CubitEntity*> &list)
1111 : : {
1112 : 0 : int id = 1;
1113 : : CubitEntity* entity;
1114 : :
1115 [ # # ]: 0 : if (list.size())
1116 : : {
1117 : 0 : list.reset();
1118 : : // if these are ref volumes, recompute color
1119 : 0 : CubitBoolean set_color = CUBIT_FALSE;
1120 [ # # ][ # # ]: 0 : if (CAST_TO(list.get(), RefVolume)) set_color = CUBIT_TRUE;
[ # # ]
1121 : :
1122 : : // sort list so ids of entities are ascending order
1123 : 0 : list.sort( sort_by_ascending_ids);
1124 : :
1125 [ # # ]: 0 : for (int i=list.size(); i > 0; i--)
1126 : : {
1127 : 0 : entity = list.get_and_step();
1128 [ # # ]: 0 : if (entity->id() != id){
1129 : 0 : entity->set_id(id);
1130 [ # # ]: 0 : if (set_color) {
1131 : 0 : entity->color(CUBIT_DEFAULT_COLOR_INDEX);
1132 : : }
1133 : : }
1134 : 0 : id++;
1135 : : }
1136 : : }
1137 : 0 : }
1138 : :
1139 : 1206 : void RefEntityFactory::reset_ids()
1140 : : {
1141 : 1206 : maxBodyId = 0;
1142 : 1206 : maxRefVolumeId = 0;
1143 : 1206 : maxRefGroupId = 0;
1144 : 1206 : maxRefFaceId = 0;
1145 : 1206 : maxRefEdgeId = 0;
1146 : 1206 : maxRefVertexId = 0;
1147 : 1206 : maxSurfSubDomainId = 0;
1148 : 1206 : maxCurveSubDomainId = 0;
1149 : 1206 : maxRefCoordSysId = 0;
1150 : : #ifdef PROE
1151 : : maxRefAssemblyId = 0;
1152 : : maxRefPartId = 0;
1153 : : #endif
1154 : 1206 : }
1155 : :
1156 : : #if 0
1157 : : static int re_factory_sort_volumes(RefVolume*& /*a*/, RefVolume*& /*b*/)
1158 : : {
1159 : : // This is currently not implemented. When it is added to CGM,
1160 : : // look at MRefEntityFactory to see what to do.
1161 : : return 0;
1162 : : }
1163 : : #endif
1164 : :
1165 : 0 : void RefEntityFactory::renumber_geometry_by_properties(CubitBoolean retain_max)
1166 : : {
1167 : : // See MRefEntityFactory::renumber_geometry_by_properties.
1168 : : // If you want this implemented, copy what was done there.
1169 [ # # ]: 0 : PRINT_ERROR("'Sort' option not supported.\n"
1170 [ # # ]: 0 : " Compressing IDs without sorting.");
1171 : 0 : compress_ref_ids("group", retain_max);
1172 : 0 : compress_ref_ids("body", retain_max);
1173 : 0 : compress_ref_ids("volume", retain_max);
1174 : 0 : compress_ref_ids("surface", retain_max);
1175 : 0 : compress_ref_ids("curve", retain_max);
1176 : 0 : compress_ref_ids("vertex", retain_max);
1177 : 0 : }
1178 : :
1179 : 241275 : void RefEntityFactory::notify_observer(const CubitEvent *observer_event)
1180 : : {
1181 : :
1182 [ - + ]: 241275 : const GeometryEvent* geom_event = dynamic_cast<const GeometryEvent*>(observer_event);
1183 [ + + ]: 241275 : if(!geom_event)
1184 : 97936 : return;
1185 : :
1186 : 143339 : RefEntity* entity = geom_event->get_entity();
1187 : :
1188 : : //- handle MODEL_ENTITY_DESTRUCTED/MODEL_ENTITY_CONSTRUCTED events
1189 [ + + ]: 143339 : if (geom_event->get_type() == GeometryEvent::TOPOLOGY_ENTITY_CONSTRUCTED)
1190 : 81482 : add(entity);
1191 [ + + ]: 61857 : else if (geom_event->get_type() == GeometryEvent::TOPOLOGY_ENTITY_DESTRUCTED)
1192 : 50333 : remove(entity);
1193 [ + + ]: 11524 : else if (geom_event->get_type() == GeometryEvent::ID_SET)
1194 : : {
1195 [ + - ][ - + ]: 88 : if(CAST_TO(entity, RefEdge) && ManageListSorting)
[ # # ][ - + ]
1196 : 0 : refEdgeListIsSorted = false;
1197 [ + - ][ - + ]: 88 : else if(CAST_TO(entity, RefFace) && ManageListSorting)
[ # # ][ - + ]
1198 : 0 : refFaceListIsSorted = false;
1199 [ + - ][ - + ]: 88 : else if(CAST_TO(entity, RefVertex) && ManageListSorting)
[ # # ][ - + ]
1200 : 0 : refVertexListIsSorted = false;
1201 [ + - ][ - + ]: 88 : else if(CAST_TO(entity, RefVolume) && ManageListSorting)
[ # # ][ - + ]
1202 : 0 : refVolumeListIsSorted = false;
1203 [ + - ][ + + ]: 88 : else if(CAST_TO(entity, RefGroup) && ManageListSorting)
[ + - ][ + + ]
1204 : 22 : refGroupListIsSorted = false;
1205 [ + - ][ + - ]: 66 : else if(CAST_TO(entity, Body) && ManageListSorting)
[ + - ][ + - ]
1206 : 66 : bodyListIsSorted = false;
1207 : : }
1208 [ + - ][ + - ]: 6540 : }
1209 : :
|
