Branch data Line data Source code
1 : : //- class: CubitAttribUser
2 : : //- Owner: Greg Nielson
3 : : //- Description: implementation of CubitAttribUser class.
4 : : //- Checked By:
5 : : //- Version: $Id:
6 : :
7 : :
8 : : // #include "CubitSimpleAttrib.hpp"
9 : : #include "CubitAttribUser.hpp"
10 : : #include "CastTo.hpp"
11 : : #include "Body.hpp"
12 : : #include "GeometryEntity.hpp"
13 : : #include "BasicTopologyEntity.hpp"
14 : : #include "BodySM.hpp"
15 : : #include "CAGroup.hpp"
16 : : #include "CAMergePartner.hpp"
17 : : //#include "CADeferredAttrib.hpp"
18 : : #include "RefFace.hpp"
19 : : #include "RefEdge.hpp"
20 : : #include "RefVertex.hpp"
21 : : // #include "DLIList.hpp"
22 : : // #include "CubitString.hpp"
23 : : #include "GeometryModifyTool.hpp"
24 : : #include "BridgeManager.hpp"
25 : : #include "CubitMessage.hpp"
26 : :
27 : :
28 : 81482 : CubitAttribUser::CubitAttribUser(CubitAttrib* cubit_attrib_ptr)
29 : : {
30 : 81482 : headAttrib = cubit_attrib_ptr;
31 : 81482 : }
32 : :
33 : 50333 : CubitAttribUser::~CubitAttribUser()
34 : : {
35 : : //delete all ToolData's chained off this user.
36 : 50333 : CubitAttrib *ca_ptr = headAttrib;
37 : :
38 [ + + ]: 75430 : while ( ca_ptr) {
39 : 25097 : CubitAttrib *next = ca_ptr->next_attrib();
40 [ + - ]: 25097 : delete ca_ptr;
41 : 25097 : ca_ptr = next;
42 : : }
43 : :
44 : 50333 : headAttrib = NULL;
45 [ - + ]: 50333 : }
46 : :
47 : 279713 : CubitAttrib* CubitAttribUser::get_cubit_attrib (int attrib_type,
48 : : CubitBoolean create_if_missing)
49 : : {
50 : 279713 : CubitAttrib* cubit_attrib_ptr = NULL;
51 : 279713 : RefEntity* entity = NULL;
52 [ + - ]: 279713 : DLIList<CubitAttrib*> attrib_list;
53 [ + - ]: 279713 : find_cubit_attrib_type (attrib_type, attrib_list);
54 [ + - ][ + + ]: 279713 : if (attrib_list.size() > 0)
55 [ + - ]: 171835 : cubit_attrib_ptr = attrib_list.get();
56 [ + + ]: 107878 : else if ( create_if_missing == CUBIT_TRUE )
57 : : {
58 [ - + ]: 74661 : entity = CAST_TO(this, RefEntity);
59 [ + - ][ + - ]: 74661 : cubit_attrib_ptr = CGMApp::instance()->attrib_manager()->create_cubit_attrib(attrib_type, entity, CubitSimpleAttrib());
[ + - ][ + - ]
[ + - ]
60 : : }
61 : :
62 [ + - ]: 279713 : return cubit_attrib_ptr;
63 : : }
64 : :
65 : 241710 : CubitStatus CubitAttribUser::add_cubit_attrib (CubitAttrib* cubit_attrib_ptr)
66 : : {
67 [ - + ]: 241710 : if (cubit_attrib_ptr == NULL)
68 : 0 : return CUBIT_FAILURE;
69 : :
70 : 241710 : CubitStatus cubit_attribute_status = CUBIT_FAILURE;
71 : : CubitAttrib *temp_ptr;
72 : :
73 [ + + ]: 241710 : if (headAttrib == NULL)
74 : : {
75 : 66903 : headAttrib = cubit_attrib_ptr;
76 : 66903 : cubit_attribute_status = CUBIT_SUCCESS;
77 : : }
78 : : else
79 : : {
80 [ + + ]: 1062028 : for(temp_ptr = headAttrib;
81 : 887221 : temp_ptr->next_attrib() != NULL;
82 : : temp_ptr = temp_ptr->next_attrib());
83 : 174807 : temp_ptr->set_next_attrib(cubit_attrib_ptr);
84 : 174807 : cubit_attribute_status = CUBIT_SUCCESS;
85 : : }
86 : 241710 : return cubit_attribute_status;
87 : : }
88 : :
89 : 26451 : CubitStatus CubitAttribUser::put_simple_attrib
90 : : (const CubitSimpleAttrib& new_csattrib_ptr, CubitBoolean append_it)
91 : : {
92 : : Body* Body_ptr;
93 [ - + ]: 26451 : Body_ptr = CAST_TO(this, Body);
94 : : BasicTopologyEntity* BTE_ptr;
95 [ - + ]: 26451 : BTE_ptr = CAST_TO(this, BasicTopologyEntity);
96 [ + + ]: 26451 : if ( Body_ptr != NULL )
97 : : {
98 : : // Get the OSME pointer
99 : 1520 : BodySM* OSME_ptr = Body_ptr->get_body_sm_ptr();
100 : :
101 : : // check for duplicates
102 [ - + ]: 1520 : if (DEBUG_FLAG(94))
103 : : {
104 [ # # ]: 0 : DLIList<CubitSimpleAttrib> cs_list;
105 [ # # ]: 0 : OSME_ptr->get_simple_attribute(cs_list);
106 [ # # ][ # # ]: 0 : for (int i = cs_list.size(); i > 0; i--)
107 : : {
108 [ # # ][ # # ]: 0 : const CubitSimpleAttrib cs_attrib = cs_list.get_and_step();
109 [ # # ][ # # ]: 0 : if (cs_attrib == new_csattrib_ptr)
110 [ # # ][ # # ]: 0 : PRINT_INFO("Trying to add equivalent attribute of type %s on Body %d.\n",
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
111 [ # # ]: 0 : new_csattrib_ptr.character_type().c_str(), Body_ptr->id());
112 [ # # ][ # # ]: 0 : else if (cs_attrib.character_type() == new_csattrib_ptr.character_type())
[ # # ][ # # ]
[ # # ][ # # ]
113 [ # # ][ # # ]: 0 : PRINT_INFO("Trying to add attribute of same type %s on Body %d.\n",
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
114 [ # # ]: 0 : new_csattrib_ptr.character_type().c_str(), Body_ptr->id());
115 [ # # ][ # # ]: 0 : }
116 : : }
117 : :
118 : : //________ Change Code by DZ of Cat, 3/11/99 12:25:30 PM ________
119 : : // Attach this name to it
120 [ + - ]: 1520 : if ( append_it )
121 : 1520 : append_simple_attribute(OSME_ptr, new_csattrib_ptr);
122 : : //________ Change End by DZ of Cat, 3/11/99 12:25:30 PM ________
123 : : }
124 : : // Deal with BasicTopologyEntities
125 [ + + ]: 24931 : else if ( BTE_ptr != NULL )
126 : : {
127 : : // Get the GeometryEntity pointer
128 : : GeometryEntity* GE_ptr =
129 : 24899 : BTE_ptr->get_geometry_entity_ptr();
130 : :
131 [ + + ]: 24899 : if( NULL == GE_ptr )
132 : 33 : return CUBIT_FAILURE;
133 : :
134 : : // check for duplicates
135 [ - + ]: 24866 : if (DEBUG_FLAG(94))
136 : : {
137 [ # # ]: 0 : DLIList<CubitSimpleAttrib> cs_list;
138 [ # # ]: 0 : GE_ptr->get_simple_attribute(cs_list);
139 [ # # ][ # # ]: 0 : for (int i = cs_list.size(); i > 0; i--)
140 : : {
141 [ # # ]: 0 : const CubitSimpleAttrib &cs_attrib = cs_list.get_and_step();
142 [ # # ][ # # ]: 0 : if (cs_attrib == new_csattrib_ptr)
143 [ # # ][ # # ]: 0 : PRINT_INFO("Trying to add equivalent attribute of type %s on %s %d.\n",
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
144 : : new_csattrib_ptr.character_type().c_str(),
145 [ # # ]: 0 : BTE_ptr->class_name(), BTE_ptr->id());
146 [ # # ][ # # ]: 0 : else if (cs_attrib.character_type() == new_csattrib_ptr.character_type())
[ # # ][ # # ]
[ # # ][ # # ]
147 [ # # ][ # # ]: 0 : PRINT_INFO("Trying to add attribute of same type %s on %s %d.\n",
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
148 : : new_csattrib_ptr.character_type().c_str(),
149 [ # # ]: 0 : BTE_ptr->class_name(), BTE_ptr->id());
150 [ # # ]: 0 : }
151 : : }
152 : :
153 : : //_________ Add Code by DZ of Cat, 3/11/99 11:10:29 AM _________
154 : : // Attach this name to it
155 [ + - ]: 24866 : if ( append_it )
156 : 24866 : append_simple_attribute(GE_ptr, new_csattrib_ptr);
157 : : //_________ Code End by DZ of Cat, 3/11/99 11:10:29 AM _________
158 : :
159 : : }
160 : : // Deal with all other RefEntities. As these do not have any
161 : : // underlying entities (such as solid model entities) associated
162 : : // with them, this block is a do-nothing block.
163 : : else
164 : : {
165 : : }
166 : :
167 [ - + ]: 26418 : if (DEBUG_FLAG(90))
168 : : {
169 [ # # ]: 0 : RefEntity *ref_entity = CAST_TO(this, RefEntity);
170 [ # # ][ # # ]: 0 : PRINT_DEBUG_90( "Putting simple attribute of type %s on"
[ # # ][ # # ]
[ # # ]
171 : : " %s %d.\n", new_csattrib_ptr.character_type().c_str(),
172 [ # # ]: 0 : ref_entity->class_name(), ref_entity->id());
173 : : }
174 : :
175 : 26451 : return CUBIT_SUCCESS;
176 : : }
177 : :
178 : 58379 : CubitStatus CubitAttribUser::clear_simple_attribs_set_to_actuate()
179 : : {
180 : 58379 : CubitAttrib *cubit_attrib_ptr = NULL;
181 : 58379 : CubitAttrib *next_attrib_ptr = NULL;
182 [ + + ]: 62408 : for(cubit_attrib_ptr = headAttrib;
183 : : cubit_attrib_ptr != NULL;)
184 : : {
185 : : //ignore Assembly and Name attributes
186 : 4029 : next_attrib_ptr = cubit_attrib_ptr->next_attrib();
187 [ + - ][ + + ]: 11151 : if( cubit_attrib_ptr->int_attrib_type() != CA_ENTITY_NAME &&
188 [ + + ][ + - ]: 7122 : cubit_attrib_ptr->int_attrib_type() != CA_ASSEMBLY_DATA &&
189 : : CGMApp::instance()->attrib_manager()->auto_actuate_flag(
190 : 3093 : cubit_attrib_ptr->int_attrib_type()))
191 : : {
192 : 3093 : remove_cubit_attrib( cubit_attrib_ptr );
193 [ + - ]: 3093 : delete cubit_attrib_ptr;
194 : : }
195 : 4029 : cubit_attrib_ptr = next_attrib_ptr;
196 : : }
197 : :
198 [ - + ]: 58379 : if (DEBUG_FLAG(94))
199 : : {
200 [ # # ][ # # ]: 0 : PRINT_DEBUG_94("CubitAttribUser::clear_simple_attribs()\n");
[ # # ]
201 : : }
202 [ - + ]: 58379 : TopologyEntity* te_ptr = dynamic_cast<TopologyEntity*>(this);
203 [ - + ]: 58379 : if( !te_ptr )
204 : 0 : return CUBIT_FAILURE;
205 : :
206 : 58379 : remove_all_simple_attribute(te_ptr->bridge_manager()->topology_bridge());
207 : 58379 : write_cubit_attrib_by_type(CA_ASSEMBLY_DATA);
208 : 58379 : write_cubit_attrib_by_type( CA_ENTITY_NAME );
209 : 58379 : set_written_flag(CUBIT_FALSE);
210 : 58379 : return CUBIT_SUCCESS;
211 : : }
212 : :
213 : 30884 : CubitStatus CubitAttribUser::clear_simple_attribs()
214 : : {
215 : :
216 : 30884 : CubitAttrib *cubit_attrib_ptr = NULL;
217 : 30884 : CubitAttrib *next_attrib_ptr = NULL;
218 [ + + ]: 43131 : for(cubit_attrib_ptr = headAttrib;
219 : : cubit_attrib_ptr != NULL;)
220 : : {
221 : : //ignore Assembly and Name attributes
222 : 12247 : next_attrib_ptr = cubit_attrib_ptr->next_attrib();
223 [ + + + - ]: 21868 : if( cubit_attrib_ptr->int_attrib_type() != CA_ENTITY_NAME &&
[ + + ]
224 : 9621 : cubit_attrib_ptr->int_attrib_type() != CA_ASSEMBLY_DATA)
225 : : {
226 : 9621 : remove_cubit_attrib( cubit_attrib_ptr );
227 [ + - ]: 9621 : delete cubit_attrib_ptr;
228 : : }
229 : 12247 : cubit_attrib_ptr = next_attrib_ptr;
230 : : }
231 : :
232 [ - + ]: 30884 : if (DEBUG_FLAG(94))
233 : : {
234 [ # # ][ # # ]: 0 : PRINT_DEBUG_94("CubitAttribUser::clear_simple_attribs()\n");
[ # # ]
235 : : }
236 [ - + ]: 30884 : TopologyEntity* te_ptr = dynamic_cast<TopologyEntity*>(this);
237 [ - + ]: 30884 : if( !te_ptr )
238 : 0 : return CUBIT_FAILURE;
239 : :
240 : 30884 : remove_all_simple_attribute(te_ptr->bridge_manager()->topology_bridge());
241 : :
242 : 30884 : update_cubit_attrib(CA_ASSEMBLY_DATA);
243 : 30884 : write_cubit_attrib_by_type(CA_ASSEMBLY_DATA);
244 : 30884 : update_cubit_attrib(CA_ENTITY_NAME);
245 : 30884 : write_cubit_attrib_by_type( CA_ENTITY_NAME );
246 : 30884 : set_written_flag(CUBIT_FALSE);
247 : 30884 : return CUBIT_SUCCESS;
248 : : }
249 : :
250 : 55603 : CubitStatus CubitAttribUser::write_specific_cubit_attrib(CubitAttrib* cubit_attrib_ptr)
251 : : {
252 : 55603 : CubitStatus result = CUBIT_SUCCESS;
253 : :
254 : : // don't write if this attrib is marked as deleted or it has already been written
255 : : // Also, only write if the write flag is on for this attribute type
256 [ + + + - ]: 82054 : if ((cubit_attrib_ptr->delete_attrib() != CUBIT_TRUE) &&
[ + + ]
257 : : // (cubit_attrib_ptr->has_written() != CUBIT_TRUE) &&
258 : 26451 : (CGMApp::instance()->attrib_manager()->auto_write_flag(cubit_attrib_ptr->int_attrib_type()) == CUBIT_TRUE))
259 : : {
260 : :
261 [ - + ]: 26451 : if (DEBUG_FLAG(90)) {
262 [ # # ]: 0 : RefEntity *this_entity = CAST_TO(this, RefEntity);
263 [ # # ][ # # ]: 0 : PRINT_DEBUG_90( "Writing attribute for %s %d, type %s\n",
264 : : this_entity->class_name(), this_entity->id(),
265 [ # # ]: 0 : cubit_attrib_ptr->att_internal_name());
266 : : }
267 : :
268 : : // set has_written flag here, before actually writing - a trick to
269 : : // allow some attributes to detect they're being written, and do any
270 : : // final setup they need to do before the actual write takes place (used
271 : : // in CAMeshContainer, for example)
272 : 26451 : cubit_attrib_ptr->has_written(CUBIT_TRUE);
273 : :
274 : 26451 : const CubitSimpleAttrib &csa_ptr = cubit_attrib_ptr->cubit_simple_attrib();
275 : :
276 [ + - ]: 26451 : result = put_simple_attrib(csa_ptr);
277 : :
278 : : // if the write wasn't successful, reset the write flag
279 [ + + ][ + - ]: 26451 : if (result != CUBIT_SUCCESS) cubit_attrib_ptr->has_written(CUBIT_FALSE);
280 : :
281 : : }
282 : :
283 : 55603 : return result;
284 : : }
285 : :
286 : 178526 : CubitStatus CubitAttribUser::write_cubit_attrib_by_type(int attrib_type)
287 : : {
288 [ + - ]: 178526 : DLIList<CubitAttrib*> attrib_list;
289 [ + - ]: 178526 : find_cubit_attrib_type(attrib_type, attrib_list);
290 [ + - ][ + - ]: 178526 : CubitStatus write_status = write_cubit_attrib_list(attrib_list);
[ + - ]
291 [ + - ]: 178526 : return write_status;
292 : : }
293 : :
294 : 178526 : CubitStatus CubitAttribUser::write_cubit_attrib_list(DLIList<CubitAttrib*>
295 : : attrib_list)
296 : : {
297 : 178526 : CubitStatus write_status = CUBIT_SUCCESS;
298 : 178526 : attrib_list.reset();
299 [ + + ]: 210346 : for(int i = attrib_list.size(); i > 0; i--)
300 : : {
301 : 31820 : CubitAttrib* cubit_attrib_ptr = attrib_list.get_and_step();
302 [ - + ]: 31820 : if (write_specific_cubit_attrib(cubit_attrib_ptr) == CUBIT_FAILURE)
303 : 0 : write_status = CUBIT_FAILURE;
304 : : }
305 : 178526 : return write_status;
306 : : }
307 : :
308 : 32396 : CubitStatus CubitAttribUser::write_cubit_attribs()
309 : : {
310 : : // write the attributes
311 : 32396 : CubitStatus write_status = CUBIT_SUCCESS;
312 [ + - ]: 32396 : DLIList<CubitAttrib*> attrib_list;
313 : : CubitAttrib *attrib;
314 [ + - ]: 32396 : get_cubit_attrib_list(attrib_list);
315 [ + - ]: 32396 : attrib_list.reset();
316 : : int i;
317 [ + - ][ + + ]: 51034 : for(i = attrib_list.size(); i != 0; i--)
318 : : {
319 [ + - ]: 18638 : attrib = attrib_list.get_and_step();
320 [ + - ][ - + ]: 18638 : if (write_specific_cubit_attrib(attrib) == CUBIT_FAILURE)
321 : 0 : write_status = CUBIT_FAILURE;
322 : : }
323 : :
324 [ + - ]: 32396 : return write_status;
325 : : }
326 : :
327 : 0 : void CubitAttribUser::split_owner(DLIList<CubitSimpleAttrib> &csa_list)
328 : : {
329 : :
330 : : //- if owner is to be split, get simple attribs for new entity
331 : :
332 : : // first auto create attributes
333 : : /*CubitStatus success = */
334 [ # # ][ # # ]: 0 : CGMApp::instance()->attrib_manager()->auto_update_attribs(CAST_TO(this, RefEntity));
[ # # ][ # # ]
335 : :
336 : : // call split for each attribute, getting back new csa's
337 [ # # ]: 0 : DLIList<CubitAttrib*> ca_list;
338 [ # # ]: 0 : get_cubit_attrib_list(ca_list);
339 : : int i;
340 [ # # ][ # # ]: 0 : for ( i = ca_list.size(); i > 0; i--) {
341 [ # # ]: 0 : CubitAttrib *ca_ptr = ca_list.get_and_step();
342 [ # # ]: 0 : CubitSimpleAttrib csa_ptr = ca_ptr->split_owner();
343 [ # # ][ # # ]: 0 : if (!csa_ptr.isEmpty())
344 [ # # ]: 0 : csa_list.append(csa_ptr);
345 [ # # ]: 0 : }
346 : :
347 : : // now, check delete flag for each ca_ptr, and delete if necessary
348 [ # # ][ # # ]: 0 : for (i = ca_list.size(); i > 0; i--) {
349 [ # # ]: 0 : CubitAttrib *ca_ptr = ca_list.get_and_step();
350 [ # # ][ # # ]: 0 : if (ca_ptr->delete_attrib()) {
351 [ # # ]: 0 : remove_cubit_attrib(ca_ptr);
352 [ # # ][ # # ]: 0 : delete ca_ptr;
353 : : }
354 [ # # ]: 0 : }
355 : :
356 : : // ok, we're done
357 : 0 : }
358 : :
359 : 0 : void CubitAttribUser::merge_owner(RefEntity *deletable_entity)
360 : : {
361 : : //- if owner is to be merged, combine attribs from deletable_entity with this
362 : :
363 : : // if no deletable entity, keep the entity name and delete the other
364 : : // attribs on this entity
365 : : int i;
366 [ # # ]: 0 : if (deletable_entity == NULL) {
367 [ # # ]: 0 : DLIList<CubitAttrib*> ca_list;
368 [ # # ]: 0 : get_cubit_attrib_list(ca_list);
369 [ # # ][ # # ]: 0 : for (i = ca_list.size(); i > 0; i--) {
370 [ # # ]: 0 : CubitAttrib *ca_ptr = ca_list.get_and_step();
371 [ # # ][ # # ]: 0 : if (ca_ptr->int_attrib_type() != CA_ENTITY_NAME &&
[ # # ]
372 [ # # ][ # # ]: 0 : ca_ptr->int_attrib_type() != CA_ASSEMBLY_DATA &&
[ # # ]
373 [ # # ]: 0 : ca_ptr->int_attrib_type() != CA_MESH_OUTPUT_GROUP)
374 : : {
375 [ # # ]: 0 : remove_cubit_attrib(ca_ptr);
376 [ # # ][ # # ]: 0 : delete ca_ptr;
377 : : }
378 : : }
379 : :
380 [ # # ]: 0 : return;
381 : : }
382 : :
383 : : // first auto create attributes
384 : : /*CubitStatus success = */
385 [ # # ][ # # ]: 0 : CGMApp::instance()->attrib_manager()->auto_update_attribs(CAST_TO(this, RefEntity));
[ # # ][ # # ]
386 : :
387 : : // copy any attr's on deletable_entity but not on this
388 [ # # ]: 0 : auto_create_for_merge(deletable_entity);
389 : :
390 : : // call merge for each attribute, passing other as argument
391 [ # # ][ # # ]: 0 : DLIList<CubitAttrib*> ca_list, deletable_ca_list;
[ # # ]
392 [ # # ]: 0 : get_cubit_attrib_list(ca_list);
393 [ # # ]: 0 : deletable_entity->get_cubit_attrib_list(deletable_ca_list);
394 [ # # ][ # # ]: 0 : assert(ca_list.size() >= deletable_ca_list.size());
[ # # ]
395 [ # # ][ # # ]: 0 : for (i = ca_list.size(); i > 0; i--) {
396 [ # # ]: 0 : CubitAttrib *ca_ptr = ca_list.get_and_step();
397 [ # # ]: 0 : deletable_ca_list.reset();
398 : 0 : CubitAttrib *deletable_ca_ptr = NULL;
399 [ # # ][ # # ]: 0 : if (deletable_ca_list.size() > 0) {
400 [ # # ]: 0 : deletable_ca_ptr = deletable_ca_list.get();
401 : : // get the corresponding deletable attribute, then extract it from
402 : : // the list
403 [ # # ][ # # ]: 0 : while (ca_ptr->int_attrib_type() != deletable_ca_ptr->int_attrib_type() &&
[ # # ][ # # ]
[ # # ]
404 [ # # ]: 0 : !deletable_ca_list.is_at_end()) {
405 [ # # ]: 0 : deletable_ca_list.step();
406 [ # # ]: 0 : deletable_ca_ptr = deletable_ca_list.get();
407 : : }
408 [ # # ][ # # ]: 0 : if (ca_ptr->int_attrib_type() == deletable_ca_ptr->int_attrib_type())
[ # # ]
409 [ # # ]: 0 : deletable_ca_list.extract();
410 : 0 : else deletable_ca_ptr = NULL;
411 : : }
412 [ # # ]: 0 : ca_ptr->merge_owner(deletable_ca_ptr);
413 : : }
414 : :
415 : : // now, check delete flag for each ca_ptr, and delete if necessary
416 [ # # ][ # # ]: 0 : for (i = ca_list.size(); i > 0; i--) {
417 [ # # ]: 0 : CubitAttrib *ca_ptr = ca_list.get_and_step();
418 [ # # ][ # # ]: 0 : if (ca_ptr->delete_attrib()) {
419 [ # # ]: 0 : remove_cubit_attrib(ca_ptr);
420 [ # # ][ # # ]: 0 : delete ca_ptr;
421 : : }
422 [ # # ]: 0 : }
423 : :
424 : : // ok, we're done
425 : : }
426 : :
427 : 0 : void CubitAttribUser::transf_owner(const CubitVector &matrow1,
428 : : const CubitVector &matrow2,
429 : : const CubitVector &matrow3,
430 : : const CubitVector &translate_vec,
431 : : const double scale_factor)
432 : : {
433 : :
434 : : //- called if owner is to be transformed; simply passes information
435 : : //- to attribs on this entity; does *not* autocreate
436 : :
437 [ # # ]: 0 : DLIList<CubitAttrib*> ca_list;
438 [ # # ]: 0 : get_cubit_attrib_list(ca_list);
439 [ # # ][ # # ]: 0 : for (int i = ca_list.size(); i > 0; i--) {
440 [ # # ]: 0 : CubitAttrib *ca_ptr = ca_list.get_and_step();
441 : : ca_ptr->transf_owner(matrow1, matrow2, matrow3,
442 [ # # ]: 0 : translate_vec, scale_factor);
443 [ # # ]: 0 : }
444 : :
445 : : // ok, we're done
446 : 0 : }
447 : :
448 : 0 : void CubitAttribUser::auto_create_for_merge(RefEntity *deletable_entity)
449 : : {
450 : : // copy any attr's on deletable_entity but not on this
451 [ # # ]: 0 : DLIList<CubitAttrib*> deletable_ca_list;
452 [ # # ]: 0 : deletable_entity->get_cubit_attrib_list(deletable_ca_list);
453 [ # # ][ # # ]: 0 : if (deletable_ca_list.size() == 0) return;
454 : :
455 [ # # ][ # # ]: 0 : DLIList<CubitAttrib*> new_list;
[ # # ][ # # ]
456 [ # # ]: 0 : RefEntity *entity = CAST_TO(this, RefEntity);
457 [ # # ][ # # ]: 0 : for (int i = deletable_ca_list.size(); i > 0; i--) {
458 [ # # ]: 0 : new_list.clean_out();
459 [ # # ]: 0 : CubitAttrib *deletable_ca_ptr = deletable_ca_list.get_and_step();
460 [ # # ][ # # ]: 0 : find_cubit_attrib_type(deletable_ca_ptr->int_attrib_type(), new_list);
461 [ # # ][ # # ]: 0 : if (new_list.size() == 0)
462 : : {
463 : : CGMApp::instance()->attrib_manager()->create_cubit_attrib(
464 : 0 : deletable_ca_ptr->int_attrib_type(),
465 [ # # ][ # # ]: 0 : entity, CubitSimpleAttrib());
[ # # ][ # # ]
[ # # ][ # # ]
466 : : }
467 : 0 : }
468 : : }
469 : :
470 : 0 : CubitStatus CubitAttribUser::actuate_cubit_attrib (CubitAttrib* cubit_attrib_ptr)
471 : : {
472 : 0 : CubitStatus return_value = CUBIT_FAILURE;
473 [ # # ]: 0 : if (cubit_attrib_ptr != NULL )
474 : : {
475 [ # # # # ]: 0 : if (cubit_attrib_ptr->has_actuated() == CUBIT_TRUE ||
[ # # ]
476 : 0 : cubit_attrib_ptr->delete_attrib() == CUBIT_TRUE) {
477 : 0 : return CUBIT_FAILURE;
478 : : }
479 : :
480 : 0 : return_value = cubit_attrib_ptr->actuate();
481 [ # # ]: 0 : if (cubit_attrib_ptr->delete_attrib() == CUBIT_TRUE)
482 : : {
483 : 0 : return_value = remove_cubit_attrib(cubit_attrib_ptr);
484 [ # # ]: 0 : delete cubit_attrib_ptr;
485 : : }
486 : : }
487 : 0 : return return_value;
488 : : }
489 : :
490 : 0 : CubitStatus CubitAttribUser::actuate_cubit_attrib (int attrib_type)
491 : : {
492 [ # # ]: 0 : DLIList<CubitAttrib*> attrib_list;
493 [ # # ]: 0 : find_cubit_attrib_type(attrib_type, attrib_list);
494 [ # # ][ # # ]: 0 : CubitStatus actuate_status = actuate_cubit_attrib(attrib_list);
[ # # ]
495 [ # # ]: 0 : return actuate_status;
496 : : }
497 : :
498 : 0 : CubitStatus CubitAttribUser::actuate_cubit_attrib(DLIList<CubitAttrib*>
499 : : attrib_list)
500 : : {
501 : 0 : CubitStatus actuate_status = CUBIT_SUCCESS;
502 : 0 : attrib_list.reset();
503 [ # # ]: 0 : for(int i = 0; i < attrib_list.size(); i++)
504 : : {
505 : 0 : CubitAttrib* cubit_attrib_ptr = attrib_list.get_and_step();
506 [ # # ]: 0 : if (actuate_cubit_attrib(cubit_attrib_ptr) == CUBIT_FAILURE)
507 : 0 : actuate_status = CUBIT_FAILURE;
508 : : }
509 : 0 : return actuate_status;
510 : : }
511 : :
512 : 2820 : CubitStatus CubitAttribUser::actuate_cubit_attrib(DLIList<RefEntity*> refent_list,
513 : : int attrib_type)
514 : :
515 : : {
516 : 2820 : CubitStatus actuate_status = CUBIT_SUCCESS;
517 [ + - ]: 2820 : DLIList<CubitAttrib*> attrib_list;
518 : : RefEntity *ref_ent;
519 [ + - ][ + + ]: 43887 : for(int i = refent_list.size(); i > 0; i--)
520 : : {
521 [ + - ]: 41163 : ref_ent = refent_list.get_and_step();
522 [ - + ]: 41163 : TopologyEntity* me_ptr = dynamic_cast<TopologyEntity*>(ref_ent);
523 [ + - ][ + - ]: 41163 : if( me_ptr && me_ptr->deactivated() )
[ - + ][ - + ]
524 : 0 : continue;
525 [ + - ]: 41163 : ref_ent->find_cubit_attrib_type(attrib_type, attrib_list);
526 [ + - ][ + + ]: 41163 : if (attrib_list.size() > 0)
527 [ + - ][ + - ]: 96 : return ((attrib_list.get())->actuate_list(refent_list));
[ + - ][ + - ]
528 : : }
529 [ + - ]: 2820 : return actuate_status;
530 : : }
531 : :
532 : : //CubitStatus CubitAttribUser::actuate_cubit_attrib ()
533 : : //{
534 : : // CubitStatus actuate_status = CUBIT_SUCCESS;
535 : : // DLIList<CubitAttrib*> attrib_list;
536 : : // CubitAttrib *attrib;
537 : : // get_cubit_attrib_list(attrib_list);
538 : : // attrib_list.reset();
539 : : //
540 : : // for(int i = attrib_list.size(); i != 0; i--)
541 : : // {
542 : : // attrib = attrib_list.get_and_step();
543 : : // if (attrib->actuate() == CUBIT_FAILURE)
544 : : // {
545 : : // actuate_status = CUBIT_FAILURE;
546 : : // }
547 : : // if (attrib->delete_attrib() == CUBIT_TRUE)
548 : : // {
549 : : // remove_cubit_attrib(attrib);
550 : : // delete attrib;
551 : : // }
552 : : // }
553 : : // return actuate_status;
554 : : //}
555 : :
556 : 203166 : CubitStatus CubitAttribUser::auto_actuate_cubit_attrib (CubitBoolean from_constructor,
557 : : CubitBoolean after_geom_changes)
558 : : {
559 : 203166 : CubitStatus actuate_status = CUBIT_SUCCESS;
560 : : CubitAttrib *attrib;
561 [ + - ]: 203166 : DLIList<CubitAttrib*> attrib_list;
562 [ + - ]: 203166 : get_cubit_attrib_list(attrib_list);
563 [ + - ]: 203166 : attrib_list.reset();
564 : : int i;
565 [ + - ][ + + ]: 217608 : for( i = attrib_list.size(); i != 0; i--)
566 : : {
567 [ + - ]: 14442 : attrib = attrib_list.get_and_step();
568 : : // check first for deletable attribute; this attribute shouldn't really be here,
569 : : // but until we figure out why it is...
570 [ + - ][ - + ]: 14442 : if (attrib->delete_attrib() == CUBIT_TRUE) {
571 [ # # ][ # # ]: 0 : PRINT_DEBUG_90("Trying to auto actuate deletable attribute - this is bad...\n");
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
572 : : }
573 [ + - ][ + + ]: 43326 : else if (attrib->auto_actuate_flag() == CUBIT_TRUE &&
[ + + ]
574 [ + - ][ + + ]: 22848 : !attrib->has_actuated() &&
575 [ + - ][ + - ]: 35493 : (!from_constructor || attrib->actuate_in_constructor()) &&
[ + + ][ + + ]
576 [ + - ][ + - ]: 6609 : (after_geom_changes || !attrib->actuate_after_geom_changes()))
577 : : {
578 : :
579 [ + - ][ + - ]: 7837 : PRINT_DEBUG_90("Actuating attribute type %s for %s %d\n",
[ - + ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
580 : : attrib->att_internal_name(), attrib->attrib_owner()->class_name(),
581 [ # # ]: 0 : attrib->attrib_owner()->id());
582 : :
583 [ + - ][ + + ]: 7837 : if(attrib->actuate() == CUBIT_FAILURE)
584 : : {
585 : 2992 : actuate_status = CUBIT_FAILURE;
586 : : }
587 : :
588 : : // need to check again for delete flag, since it might have been set
589 : : // in actuate function
590 [ + - ][ + + ]: 7837 : if( attrib->delete_attrib() == CUBIT_TRUE)
591 : : {
592 [ + - ]: 569 : remove_cubit_attrib(attrib);
593 [ + - ][ + - ]: 569 : delete attrib;
594 : : }
595 : : }
596 : : }
597 : :
598 : : // if (CADeferredAttrib::cleanup_cadas(from_constructor, after_geom_changes) == CUBIT_FAILURE)
599 : : // actuate_status = CUBIT_FAILURE;
600 : :
601 [ + - ]: 203166 : return actuate_status;
602 : : }
603 : :
604 : : //CubitStatus CubitAttribUser::update_cubit_attrib (CubitAttrib* cubit_attrib_ptr)
605 : : //{
606 : : // if (cubit_attrib_ptr != NULL)
607 : : // return cubit_attrib_ptr->update();
608 : : // return CUBIT_FAILURE;
609 : : //}
610 : :
611 : 61768 : CubitStatus CubitAttribUser::update_cubit_attrib (int attrib_type)
612 : : {
613 [ + - ]: 61768 : DLIList<CubitAttrib*> attrib_list;
614 : 61768 : CubitAttrib* new_attrib = NULL;
615 [ + - ]: 61768 : find_cubit_attrib_type(attrib_type, attrib_list);
616 : :
617 [ + - ][ - + ]: 61768 : if( attrib_list.size() > 1 )
618 : : {
619 [ # # ][ # # ]: 0 : PRINT_WARNING("File contains multiples of the same attrib.\n");
[ # # ][ # # ]
620 [ # # ][ # # ]: 0 : PRINT_INFO(" Something was not written correctly.\n");
[ # # ][ # # ]
621 : : }
622 : :
623 [ + - ][ + + ]: 61768 : if(attrib_list.size() == 0)
624 [ + - ]: 59142 : new_attrib = get_cubit_attrib(attrib_type);
625 : : else
626 [ + - ]: 2626 : new_attrib = attrib_list.get();
627 : :
628 [ - + ]: 61768 : assert(new_attrib != 0);
629 [ + - ]: 61768 : CubitStatus update_status = new_attrib->update();
630 : :
631 [ + - ]: 61768 : return update_status;
632 : : }
633 : :
634 : : //CubitStatus CubitAttribUser::update_cubit_attrib(DLIList<CubitAttrib*>
635 : : // attrib_list)
636 : : //{
637 : : // CubitStatus update_status = CUBIT_SUCCESS;
638 : : // attrib_list.reset();
639 : : // for(int i = attrib_list.size(); i > 0; i--)
640 : : // {
641 : : // CubitAttrib* cubit_attrib_ptr = attrib_list.get_and_step();
642 : : // if (cubit_attrib_ptr->update() == CUBIT_FAILURE)
643 : : // update_status = CUBIT_FAILURE;
644 : : // }
645 : : // return update_status;
646 : : //}
647 : :
648 : : //CubitStatus CubitAttribUser::update_cubit_attrib()
649 : : //{
650 : : // return CUBIT_FAILURE;
651 : : //}
652 : :
653 : 32396 : CubitStatus CubitAttribUser::auto_update_cubit_attrib ()
654 : : {
655 : :
656 : : // for this cau, automatically create and update ca's
657 : :
658 : : // first, create ca's for any attribute type which has its auto
659 : : // update flag set and which isn't present yet on this entity
660 : : /*CubitStatus success = */
661 [ - + ][ + - ]: 32396 : CGMApp::instance()->attrib_manager()->auto_update_attribs(CAST_TO(this, RefEntity));
[ + - ][ + - ]
662 : :
663 : : // now, update all attributes present on this entity
664 : 32396 : CubitStatus update_status = CUBIT_SUCCESS;
665 [ + - ]: 32396 : DLIList<CubitAttrib*> attrib_list;
666 [ + - ][ + - ]: 64792 : DLIList<CubitAttrib*> attribs_to_delete;
667 : : CubitAttrib *attrib;
668 [ + - ]: 32396 : get_cubit_attrib_list(attrib_list);
669 [ + - ]: 32396 : attrib_list.reset();
670 : : int i;
671 [ + - ][ + + ]: 239546 : for( i = attrib_list.size(); i != 0; i--)
672 : : {
673 [ + - ]: 207150 : attrib = attrib_list.get_and_step();
674 [ + - ][ + + ]: 207150 : if (!attrib->has_updated()) {
675 : : // if this attribute has written already, reset the information in it
676 : : // so it gets a "clean" update (otherwise information can be added to
677 : : // lists on the attrib more than once)
678 [ + - ][ + + ]: 204126 : if (CUBIT_TRUE == attrib->has_written())
679 [ + - ]: 60 : attrib->reset();
680 : :
681 : : // reset the delete flag here, so we don't need to do it in every attribute
682 : : // (it'll get set back to delete if the update isn't successful)
683 [ + - ]: 204126 : attrib->delete_attrib(CUBIT_FALSE);
684 [ + - ][ + - ]: 204126 : PRINT_DEBUG_90("Updating attribute type %s for %s %d, delete = ",
[ - + ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
685 : : attrib->att_internal_name(), attrib->attrib_owner()->class_name(),
686 [ # # ]: 0 : attrib->attrib_owner()->id());
687 [ + - ]: 204126 : update_status = attrib->update();
688 : :
689 [ + - ][ + + ]: 204126 : if( attrib->delete_attrib() )
690 [ + - ]: 188512 : attribs_to_delete.append( attrib );
691 : :
692 [ + - ][ + - ]: 204126 : PRINT_DEBUG_90("%s\n",
[ - + ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
693 [ # # ]: 0 : (attrib->delete_attrib() == CUBIT_FALSE ? "NO" : "YES"));
694 : :
695 : : // if update was successful, reset the written flag (assumes that all
696 : : // updates are done before writing starts)
697 : : // (don't reset if it's the entity_name attrib, since this attrib is
698 : : // written automatically every time it's updated)
699 [ + - ][ + - ]: 204126 : if (update_status == CUBIT_SUCCESS && attrib->int_attrib_type() != CA_ENTITY_NAME)
[ + + ][ + + ]
700 [ + - ]: 171730 : attrib->has_written(CUBIT_FALSE);
701 : : }
702 : : else
703 : : {
704 [ + - ][ + - ]: 3024 : PRINT_DEBUG_90("Not updating attribute type %s for %s %d, delete = ",
[ - + ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
705 : : attrib->att_internal_name(), attrib->attrib_owner()->class_name(),
706 [ # # ]: 0 : attrib->attrib_owner()->id());
707 [ + - ][ + - ]: 3024 : PRINT_DEBUG_90("%s\n",
[ - + ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
708 [ # # ]: 0 : (attrib->delete_attrib() == CUBIT_FALSE ? "NO" : "YES"));
709 : : }
710 : : }
711 : :
712 : :
713 : : //remove any attribs that don't need to be there
714 [ + - ][ + - ]: 32396 : remove_cubit_attrib( attribs_to_delete );
[ + - ]
715 : :
716 : : /*
717 : : RefEntity* re_ptr;
718 : : re_ptr = CAST_TO(this, RefEntity);
719 : : DLIList<RefEntity*> children;
720 : : re_ptr->get_child_ref_entities( children );
721 : : for ( i = children.size(); i > 0; i-- )
722 : : {
723 : : children.get()->auto_update_cubit_attrib();
724 : : children.step();
725 : : }
726 : : */
727 [ + - ]: 32396 : return update_status;
728 : : }
729 : :
730 : 615 : void CubitAttribUser::auto_reset_cubit_attrib (DLIList<RefEntity*> ref_ents)
731 : : {
732 : : // set the update flag back off for all attribs on these entities and their children
733 [ + - ][ + - ]: 1230 : DLIList<RefEntity*> children, temp_list;
[ + - ]
734 : : int i;
735 [ + - ][ + + ]: 33011 : for (i = ref_ents.size(); i > 0; i--) {
736 [ + - ]: 32396 : temp_list.clean_out();
737 [ + - ][ + - ]: 32396 : ref_ents.get_and_step()->get_all_child_ref_entities(temp_list);
738 [ + - ]: 32396 : children += temp_list;
739 : : }
740 [ + - ]: 615 : ref_ents.merge_unique(children);
741 : :
742 : : // ok, have a unique'd list if entities; now reset on each of them
743 [ + - ]: 615 : ref_ents.reset();
744 [ + - ][ + + ]: 33011 : for (i = ref_ents.size(); i > 0; i--) {
745 [ + - ][ + - ]: 32396 : ref_ents.get()->set_written_flag(CUBIT_FALSE);
746 [ + - ][ + - ]: 32396 : ref_ents.get_and_step()->set_updated_flag(CUBIT_FALSE);
747 [ + - ]: 615 : }
748 : 615 : }
749 : :
750 : : //void CubitAttribUser::auto_reset_cubit_attrib ()
751 : : //{
752 : : // // set the update flag back off for all attribs on these entities and their children
753 : : // DLIList<CubitAttrib*> attrib_list;
754 : : // CubitAttrib *attrib;
755 : : // get_cubit_attrib_list(attrib_list);
756 : : // attrib_list.reset();
757 : : // int i;
758 : : // for( i = attrib_list.size(); i != 0; i--)
759 : : // {
760 : : // attrib = attrib_list.get_and_step();
761 : : // if (attrib->has_updated() && attrib->has_written())
762 : : // attrib->has_updated(CUBIT_FALSE);
763 : : // }
764 : : //}
765 : :
766 : 615 : CubitStatus CubitAttribUser::auto_update_cubit_attrib (DLIList<RefEntity*> &entity_list,
767 : : CubitBoolean write_too)
768 : : {
769 : : //- for entity_list, auto create, update and write ca's
770 : :
771 : : // now, reset the update and write flags for these entities
772 : : // and their children
773 [ + - ]: 615 : auto_reset_cubit_attrib(entity_list);
774 : :
775 : : // need to update all then write all in separate loops,
776 : : // to prevent duplication of attributes
777 : : int i;
778 [ + + ]: 33011 : for ( i = entity_list.size(); i > 0; i--)
779 : 32396 : entity_list.get_and_step()->auto_update_cubit_attrib();
780 : :
781 [ + - ]: 615 : if (write_too) {
782 [ + + ]: 33011 : for (i = entity_list.size(); i > 0; i--)
783 : 32396 : entity_list.get_and_step()->write_cubit_attribs();
784 : : }
785 : :
786 : :
787 : 615 : return CUBIT_SUCCESS;
788 : : }
789 : :
790 : 1092 : CubitStatus CubitAttribUser::clear_all_simple_attrib( DLIList<RefEntity*>& entity_list )
791 : : {
792 : 1092 : CubitStatus result = CUBIT_SUCCESS;
793 [ + + ]: 31976 : for( int i = entity_list.size(); i--; )
794 [ - + ]: 30884 : if( entity_list.get_and_step()->clear_simple_attribs() != CUBIT_SUCCESS )
795 : 0 : result = CUBIT_FAILURE;
796 : 1092 : return result;
797 : : }
798 : :
799 : 938 : CubitStatus CubitAttribUser::clear_all_simple_attrib_set_to_actuate( DLIList<RefEntity*>& entity_list )
800 : : {
801 : 938 : CubitStatus result = CUBIT_SUCCESS;
802 [ + + ]: 59317 : for( int i = entity_list.size(); i--; )
803 [ - + ]: 58379 : if( entity_list.get_and_step()->clear_simple_attribs_set_to_actuate() != CUBIT_SUCCESS )
804 : 0 : result = CUBIT_FAILURE;
805 : 938 : return result;
806 : : }
807 : :
808 : 809280 : void CubitAttribUser::find_cubit_attrib_type(int type,
809 : : DLIList<CubitAttrib*>& attrib_list) const
810 : : {
811 [ + + ]: 2137088 : for(CubitAttrib* cubit_attrib_ptr = headAttrib;
812 : 2137088 : cubit_attrib_ptr != NULL;
813 [ + - ]: 1327808 : cubit_attrib_ptr = cubit_attrib_ptr->next_attrib())
814 : : {
815 [ + - ][ + + ]: 1327808 : if (type == cubit_attrib_ptr->int_attrib_type())
816 [ + - ]: 220533 : attrib_list.append_unique(cubit_attrib_ptr);
817 : : }
818 : 809280 : }
819 : :
820 : 32396 : CubitStatus CubitAttribUser::remove_cubit_attrib(DLIList<CubitAttrib*>
821 : : attrib_list)
822 : : {
823 : 32396 : CubitStatus remove_status = CUBIT_SUCCESS;
824 : 32396 : attrib_list.reset();
825 [ + + ]: 220908 : for(int i = attrib_list.size(); i != 0; i--)
826 : : {
827 : 188512 : CubitAttrib* cubit_attrib_ptr = attrib_list.get_and_step();
828 [ + + ]: 188512 : if (remove_cubit_attrib(cubit_attrib_ptr) == CUBIT_FAILURE)
829 : 10348 : remove_status = CUBIT_FAILURE;
830 [ + - ]: 188512 : delete cubit_attrib_ptr;
831 : : }
832 : 32396 : return remove_status;
833 : : }
834 : :
835 : 0 : CubitStatus CubitAttribUser::remove_cubit_attrib(int attrib_type)
836 : : {
837 [ # # ]: 0 : DLIList<CubitAttrib*> attrib_list;
838 [ # # ]: 0 : find_cubit_attrib_type(attrib_type, attrib_list);
839 [ # # ][ # # ]: 0 : CubitStatus remove_status = remove_cubit_attrib(attrib_list);
[ # # ]
840 [ # # ]: 0 : return remove_status;
841 : : }
842 : :
843 : 201987 : CubitStatus CubitAttribUser::remove_cubit_attrib (CubitAttrib*
844 : : cubit_attrib_ptr)
845 : : {
846 [ - + ]: 201987 : if (cubit_attrib_ptr == NULL)
847 : 0 : return CUBIT_FAILURE;
848 : 201987 : CubitStatus remove_geom = remove_attrib_geometry_entity(cubit_attrib_ptr);
849 : : //CubitStatus remove_cubit = CUBIT_FAILURE;
850 : 201987 : CubitBoolean once = CUBIT_FALSE;
851 [ + + ]: 201987 : if (headAttrib == cubit_attrib_ptr) {
852 : 113408 : headAttrib = cubit_attrib_ptr->next_attrib();
853 : 113408 : once = CUBIT_TRUE;
854 : : }
855 : :
856 : 201987 : CubitAttrib* temp_cubit_attrib_ptr = headAttrib;
857 [ + + ]: 1088767 : while (temp_cubit_attrib_ptr != NULL) {
858 [ + + ]: 886780 : if (cubit_attrib_ptr == temp_cubit_attrib_ptr->next_attrib()) {
859 [ - + ]: 88579 : if (once) {
860 [ # # ][ # # ]: 0 : PRINT_DEBUG_90("Removing attribute more than once.\n");
[ # # ]
861 : : }
862 : : temp_cubit_attrib_ptr->set_next_attrib(cubit_attrib_ptr->
863 : 88579 : next_attrib());
864 : 88579 : once = CUBIT_TRUE;
865 : : }
866 : :
867 : 886780 : temp_cubit_attrib_ptr = temp_cubit_attrib_ptr->next_attrib();
868 : : }
869 : :
870 : 201987 : return remove_geom;
871 : : }
872 : :
873 : : //CubitStatus CubitAttribUser::remove_cubit_attrib ()
874 : : //{
875 : : // CubitAttrib *cubit_attrib_ptr = NULL;
876 : : // for(cubit_attrib_ptr = headAttrib;
877 : : // cubit_attrib_ptr != NULL;)
878 : : // {
879 : : // headAttrib = cubit_attrib_ptr->next_attrib();
880 : : // delete cubit_attrib_ptr;
881 : : // cubit_attrib_ptr = headAttrib;
882 : : // }
883 : : // remove_attrib_geometry_entity();
884 : : // return CUBIT_SUCCESS;
885 : : //}
886 : :
887 : :
888 : :
889 : 81342 : CubitStatus CubitAttribUser::auto_read_cubit_attrib()
890 : : {
891 : : // auto read all simple attributes on this entity & create CA's for them;
892 : : // checks global and CA-specific auto read flag, and puts CSA's back on
893 : : // entity if auto read for that type is off
894 : :
895 : 81342 : CubitStatus cubit_assign_status = CUBIT_FAILURE;
896 : :
897 : : // Get the GeometryEntity of this RefEntity (it could be the OSME
898 : : // if it is a Body) and get its name, if it exists
899 : :
900 [ + - ]: 81342 : DLIList<CubitSimpleAttrib> csattrib_list;
901 : :
902 : : // Deal with a Body entity
903 [ - + ]: 81342 : Body* Body_ptr = CAST_TO(this, Body);
904 [ - + ]: 81342 : BasicTopologyEntity* BTE_ptr = CAST_TO(this, BasicTopologyEntity);
905 [ + + ]: 81342 : if ( Body_ptr != NULL )
906 : : {
907 [ + - ]: 2716 : BodySM* OSME_ptr = Body_ptr->get_body_sm_ptr();
908 [ + - ]: 2716 : OSME_ptr->get_simple_attribute(csattrib_list);
909 [ + - ]: 2716 : remove_all_simple_attribute(OSME_ptr);
910 : : }
911 [ + - ]: 78626 : else if ( BTE_ptr != NULL )
912 : : {
913 [ + - ]: 78626 : GeometryEntity* GE_ptr = BTE_ptr->get_geometry_entity_ptr();
914 [ + - ]: 78626 : GE_ptr->get_simple_attribute(csattrib_list);
915 [ + - ]: 78626 : remove_all_simple_attribute(GE_ptr);
916 : : }
917 : 0 : else return CUBIT_SUCCESS;
918 : :
919 [ + - ]: 81342 : csattrib_list.reset();
920 [ + - ][ + + ]: 86647 : for(int i = csattrib_list.size(); i != 0; i--)
921 : : {
922 [ + - ]: 5305 : const CubitSimpleAttrib& cubit_simple_attrib_ptr = csattrib_list.get_and_step();
923 [ + - ][ + - ]: 5305 : int csa_type = CGMApp::instance()->attrib_manager()->attrib_type(cubit_simple_attrib_ptr);
[ + - ]
924 : 5305 : CubitAttrib *new_attrib = NULL;
925 [ + - ][ + - ]: 5305 : if (CGMApp::instance()->attrib_manager()->auto_read_flag(csa_type))
[ + - ][ + - ]
926 : : // auto create this CA
927 : : new_attrib = CGMApp::instance()->attrib_manager()->create_cubit_attrib(csa_type,
928 [ - + ][ + - ]: 5305 : CAST_TO(this, RefEntity), cubit_simple_attrib_ptr);
[ + - ][ + - ]
929 : :
930 [ + - ][ + - ]: 5305 : if (new_attrib != NULL && new_attrib->delete_attrib() == CUBIT_FALSE)
[ + - ][ + - ]
931 : 5305 : cubit_assign_status = CUBIT_SUCCESS;
932 [ # # ][ # # ]: 0 : else if (new_attrib != NULL && new_attrib->delete_attrib() == CUBIT_TRUE) {
[ # # ][ # # ]
933 [ # # ]: 0 : remove_cubit_attrib(new_attrib);
934 [ # # ][ # # ]: 0 : delete new_attrib;
935 : : }
936 : : else
937 [ # # ]: 0 : put_simple_attrib(cubit_simple_attrib_ptr);
938 : : }
939 : :
940 [ + - ]: 81342 : return cubit_assign_status;
941 : : }
942 : :
943 : 0 : CubitStatus CubitAttribUser::read_cubit_attrib(int attrib_type)
944 : : {
945 : :
946 : : CubitStatus read_status;
947 : :
948 : : // get all simple attrib's
949 [ # # ]: 0 : DLIList<CubitSimpleAttrib> csattrib_list;
950 : :
951 : : // Deal with a Body entity
952 [ # # ]: 0 : Body* Body_ptr = CAST_TO(this, Body);
953 [ # # ]: 0 : BasicTopologyEntity* BTE_ptr = CAST_TO(this, BasicTopologyEntity);
954 [ # # ]: 0 : if ( Body_ptr != NULL )
955 : : {
956 [ # # ]: 0 : BodySM* OSME_ptr = Body_ptr->get_body_sm_ptr();
957 [ # # ]: 0 : read_status = OSME_ptr->get_simple_attribute(csattrib_list);
958 [ # # ]: 0 : remove_all_simple_attribute(OSME_ptr);
959 : : }
960 [ # # ]: 0 : else if ( BTE_ptr != NULL )
961 : : {
962 [ # # ]: 0 : GeometryEntity* GE_ptr = BTE_ptr->get_geometry_entity_ptr();
963 [ # # ]: 0 : read_status = GE_ptr->get_simple_attribute(csattrib_list);
964 [ # # ]: 0 : remove_all_simple_attribute(GE_ptr);
965 : : }
966 : 0 : else return CUBIT_SUCCESS;
967 : :
968 [ # # ]: 0 : csattrib_list.reset();
969 [ # # ][ # # ]: 0 : for(int i = csattrib_list.size(); i != 0; i--)
970 : : {
971 [ # # ]: 0 : const CubitSimpleAttrib& cubit_simple_attrib_ptr = csattrib_list.get_and_step();
972 [ # # ][ # # ]: 0 : int csa_type = CGMApp::instance()->attrib_manager()->attrib_type(cubit_simple_attrib_ptr);
[ # # ]
973 [ # # ][ # # ]: 0 : if (attrib_type == CA_ALL_ATTRIBUTES || csa_type == attrib_type) {
974 : : // create this CA
975 : : // CubitAttrib *new_attrib =
976 : : CGMApp::instance()->attrib_manager()->create_cubit_attrib(csa_type,
977 [ # # ][ # # ]: 0 : CAST_TO(this, RefEntity), cubit_simple_attrib_ptr);
[ # # ][ # # ]
978 : : }
979 : : else {
980 : : // otherwise we don't want to read this one; since the get_simple_attribute
981 : : // took the attribute off, we'll have to put this one back on
982 [ # # ]: 0 : put_simple_attrib(cubit_simple_attrib_ptr);
983 : : }
984 : : }
985 : :
986 [ # # ]: 0 : return read_status;
987 : : }
988 : :
989 : : //CubitStatus CubitAttribUser::read_cubit_attrib(CubitBoolean read_children)
990 : : //{
991 : : // CubitStatus read_status = CUBIT_SUCCESS;
992 : : // if (read_cubit_attrib(CA_ALL_ATTRIBUTES) == CUBIT_FAILURE)
993 : : // read_status = CUBIT_FAILURE;
994 : : //
995 : : // if (read_children) {
996 : : // // now, call read for all children
997 : : // DLIList<RefEntity*> children;
998 : : // RefEntity* re_ptr;
999 : : // re_ptr = CAST_TO(this, RefEntity);
1000 : : // re_ptr->get_all_child_ref_entities( children );
1001 : : // CubitStatus temp_status;
1002 : : // for ( int i = children.size(); i > 0; i-- )
1003 : : // {
1004 : : // temp_status = children.get()->read_cubit_attrib(CA_ALL_ATTRIBUTES);
1005 : : // if (temp_status == CUBIT_FAILURE) read_status = CUBIT_FAILURE;
1006 : : // children.step();
1007 : : // }
1008 : : // }
1009 : : //
1010 : : // return read_status;
1011 : : //}
1012 : :
1013 : 422013 : void CubitAttribUser::get_cubit_attrib_list (DLIList<CubitAttrib*>& attrib_list)
1014 : : {
1015 [ + + ]: 718079 : for(CubitAttrib* cubit_attrib_ptr = headAttrib;
1016 : 718079 : cubit_attrib_ptr != NULL;
1017 [ + - ]: 296066 : cubit_attrib_ptr = cubit_attrib_ptr->next_attrib()) {
1018 [ - + ]: 296066 : assert(NULL != cubit_attrib_ptr);
1019 [ + - ]: 296066 : attrib_list.append_unique(cubit_attrib_ptr);
1020 : : }
1021 : 422013 : }
1022 : :
1023 : 0 : int CubitAttribUser::num_cubit_attrib()
1024 : : {
1025 : 0 : int number = 0;
1026 [ # # ]: 0 : for(CubitAttrib* cubit_attrib_ptr = headAttrib;
1027 : : cubit_attrib_ptr != NULL;
1028 : : cubit_attrib_ptr = cubit_attrib_ptr->next_attrib())
1029 : 0 : number++;
1030 : :
1031 : 0 : return number;
1032 : : }
1033 : :
1034 : 204061 : CubitStatus CubitAttribUser::remove_attrib_geometry_entity (CubitAttrib*
1035 : : cubit_attrib_ptr)
1036 : : {
1037 : 204061 : CubitStatus removed = CUBIT_FAILURE;
1038 : :
1039 [ - + ]: 204061 : if(cubit_attrib_ptr == NULL)
1040 : 0 : return removed;
1041 : :
1042 [ + - ]: 204061 : CubitSimpleAttrib csattrib_ptr = cubit_attrib_ptr->cubit_simple_attrib();
1043 [ + - ][ + + ]: 204061 : if(!csattrib_ptr.isEmpty())
1044 : : {
1045 [ + - ][ + - ]: 193713 : if (DEBUG_FLAG(90)) {
[ - + ]
1046 [ # # ]: 0 : RefEntity *ref_entity = CAST_TO(this, RefEntity);
1047 [ # # ][ # # ]: 0 : PRINT_DEBUG_90( "Removing simple attribute of type %s on"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1048 : : " %s %d.\n", csattrib_ptr.character_type().c_str(),
1049 [ # # ]: 0 : ref_entity->class_name(), ref_entity->id());
1050 : : }
1051 : :
1052 [ - + ]: 193713 : TopologyEntity* topo_ptr = CAST_TO(this, TopologyEntity);
1053 [ + - ][ + - ]: 193713 : if (topo_ptr && topo_ptr->bridge_manager()->topology_bridge())
[ + - ][ + + ]
[ + + ]
1054 : : {
1055 [ + - ][ + - ]: 193449 : remove_simple_attribute(topo_ptr->bridge_manager()->topology_bridge(), csattrib_ptr);
[ + - ]
1056 : 193713 : removed = CUBIT_SUCCESS;
1057 : : }
1058 : : }
1059 [ + - ]: 204061 : return removed;
1060 : : }
1061 : :
1062 : : //CubitStatus CubitAttribUser::remove_attrib_geometry_entity ()
1063 : : //{
1064 : : // CubitStatus removed = CUBIT_FAILURE;
1065 : : // Body* Body_ptr = CAST_TO(this, Body);
1066 : : //
1067 : : // BasicTopologyEntity* BTE_ptr = CAST_TO(this, BasicTopologyEntity);
1068 : : // //Deal with Bodies
1069 : : // if ( Body_ptr != NULL )
1070 : : // {
1071 : : // // Get the OSME pointer
1072 : : // BodySM* OSME_ptr = Body_ptr->get_body_sm_ptr();
1073 : : // remove_all_simple_attribute(OSME_ptr);
1074 : : // removed = CUBIT_SUCCESS;
1075 : : // }
1076 : : //
1077 : : // // Deal with BasicTopologyEntities
1078 : : // else if ( BTE_ptr != NULL )
1079 : : // {
1080 : : // // Get the GeometryEntity pointer
1081 : : // GeometryEntity* GE_ptr =
1082 : : // BTE_ptr->get_geometry_entity_ptr();
1083 : : // remove_all_simple_attribute(GE_ptr);
1084 : : // removed = CUBIT_SUCCESS;
1085 : : // }
1086 : : //
1087 : : // // All other Entities
1088 : : // else
1089 : : // {
1090 : : // }
1091 : : // return removed;
1092 : : //}
1093 : :
1094 : 121659 : void CubitAttribUser::set_written_flag(CubitBoolean flag)
1095 : : {
1096 [ + - ]: 121659 : DLIList<CubitAttrib*> ca_list;
1097 [ + - ]: 121659 : get_cubit_attrib_list(ca_list);
1098 [ + - ][ + + ]: 165487 : for (int i = ca_list.size(); i > 0; i--) {
1099 [ + - ][ + - ]: 43828 : if (flag == CUBIT_FALSE && ca_list.get()->has_written() == CUBIT_TRUE)
[ + - ][ + + ]
[ + + ]
1100 [ + - ][ + - ]: 4936 : ca_list.get()->reset();
1101 [ + - ][ + - ]: 43828 : ca_list.get_and_step()->has_written(flag);
1102 [ + - ]: 121659 : }
1103 : 121659 : }
1104 : :
1105 : 32396 : void CubitAttribUser::set_updated_flag(CubitBoolean flag)
1106 : : {
1107 [ + - ]: 32396 : DLIList<CubitAttrib*> ca_list;
1108 [ + - ]: 32396 : get_cubit_attrib_list(ca_list);
1109 [ + - ][ + + ]: 44404 : for (int i = ca_list.size(); i > 0; i--)
1110 [ + - ][ + - ]: 44404 : ca_list.get_and_step()->has_updated(flag);
[ + - ]
1111 : 32396 : }
1112 : :
1113 : : //void CubitAttribUser::print_attribs()
1114 : : //{
1115 : : // PRINT_INFO("Attributes on %s %d:\n",
1116 : : // CAST_TO(this, RefEntity)->entity_name().c_str(),
1117 : : // CAST_TO(this, RefEntity)->id());
1118 : : // DLIList<CubitAttrib*> attrib_list;
1119 : : // get_cubit_attrib_list(attrib_list);
1120 : : // int i;
1121 : : // for (i = attrib_list.size(); i > 0; i--)
1122 : : // attrib_list.get_and_step()->print();
1123 : : //
1124 : : // if (attrib_list.size() == 0) PRINT_INFO("(none)\n");
1125 : : //}
1126 : :
1127 : 26386 : void CubitAttribUser::append_simple_attribute(TopologyBridge *bridge, const CubitSimpleAttrib& attrib_ptr)
1128 : : {
1129 : : // for merged objects, put attribute on other entities
1130 [ + - + + ]: 52772 : if (CubitSimpleAttrib::get_push_attribs() == CUBIT_TRUE ||
[ + + ]
1131 : 26386 : CGMApp::instance()->attrib_manager()->auto_update_flag(CA_MERGE_PARTNER) == CUBIT_TRUE) {
1132 : :
1133 [ + - ]: 15284 : DLIList<TopologyBridge*> tb_list;
1134 [ + - ][ + - ]: 15284 : bridge->bridge_manager()->get_bridge_list(tb_list);
1135 : :
1136 : : // if this entity is merged, it will have > 1 entity in the bridge
1137 : : // list
1138 [ + - ]: 15284 : tb_list.reset();
1139 [ + - ][ + - ]: 15284 : assert(tb_list.size() == 0 || tb_list.get() == bridge);
[ + - ][ - + ]
1140 : :
1141 : : // Special handling of MergePartner attribute.
1142 : : // Need to store the bridge sense in the attribute, which
1143 : : // is potentially different for different TopologyBridges.
1144 [ + - ][ + - ]: 15284 : int type = CGMApp::instance()->attrib_manager()->attrib_type_from_internal_name(attrib_ptr.character_type().c_str());
[ + - ][ + - ]
[ + - ][ + - ]
1145 [ + + ]: 15284 : if ( type == CA_MERGE_PARTNER )
1146 : : {
1147 [ + - ]: 1512 : CubitSimpleAttrib merge_attrib = attrib_ptr;
1148 : : // now adjust the attrib on each bridge to hold the
1149 : : // relative sense for that bridge.
1150 [ + - ][ + + ]: 4536 : for (int i = tb_list.size(); i > 0; i--) {
1151 [ + - ]: 3024 : TopologyBridge *temp_tb = tb_list.get_and_step();
1152 : :
1153 [ + - ][ + - ]: 3024 : CAMergePartner::set_bridge_sense( merge_attrib, temp_tb->bridge_sense() );
1154 : :
1155 [ - + ]: 3024 : GeometryEntity *geom_ptr = dynamic_cast<GeometryEntity*>(temp_tb);
1156 [ + - ]: 3024 : if (geom_ptr )
1157 : : {
1158 : : //if we're copying a merged entity, saved id should be zero
1159 [ + - ][ + - ]: 3024 : if( GeometryModifyTool::instance()->get_copy_entity() )
[ - + ]
1160 [ # # ]: 0 : CAMergePartner::set_saved_id( merge_attrib, 0 );
1161 : : else
1162 [ + - ][ + - ]: 3024 : CAMergePartner::set_saved_id( merge_attrib, geom_ptr->get_saved_id() );
1163 : :
1164 : : //First bridge should be marked as "survivor"
1165 [ + - ][ + + ]: 3024 : if( i == tb_list.size() )
1166 : : {
1167 [ + - ]: 1512 : CAMergePartner::set_survivor( merge_attrib, 1 );
1168 : : }
1169 : : else
1170 [ + - ]: 3024 : CAMergePartner::set_survivor( merge_attrib, 0 );
1171 : : }
1172 [ + - ]: 3024 : append_attrib_internal(temp_tb, merge_attrib);
1173 [ + - ]: 1512 : }
1174 : : }
1175 : : // For anything other than CAMergePartner, just append the
1176 : : // unmodified attribute to each bridge.
1177 : : else
1178 : : {
1179 [ + - ][ + + ]: 31168 : for ( int i = tb_list.size(); i--; )
1180 [ + - ][ + - ]: 17396 : append_attrib_internal( tb_list.get_and_step(), attrib_ptr);
1181 [ + - ]: 15284 : }
1182 : : }
1183 : : else
1184 : : {
1185 : : // Append this name to the primary bridge
1186 : 11102 : append_attrib_internal(bridge, attrib_ptr);
1187 : : }
1188 : 26386 : }
1189 : :
1190 : 31522 : void CubitAttribUser::append_attrib_internal(TopologyBridge *bridge, const CubitSimpleAttrib& attrib_ptr)
1191 : : {
1192 [ + - ]: 31522 : DLIList<CubitSimpleAttrib> others;
1193 : :
1194 : : // Check for duplicates
1195 [ + - ][ + - ]: 31522 : if ( attrib_ptr.character_type() != "DEFERRED_ATTRIB" )
[ + - ][ + - ]
[ + - ][ + - ]
1196 : : {
1197 [ + - ][ + - ]: 31522 : bridge->get_simple_attribute( attrib_ptr.character_type().c_str(), others );
[ + - ][ + - ]
[ + - ][ + - ]
1198 [ + - ][ + + ]: 45262 : while ( others.size() )
1199 : : {
1200 [ + - ][ + - ]: 13740 : bridge->remove_simple_attribute_virt( others.pop() );
[ + - ]
1201 : : }
1202 : : }
1203 : : else
1204 : : {
1205 [ # # ][ # # ]: 0 : CubitString real_name = attrib_ptr.string_data_list()[1];
[ # # ]
1206 [ # # ][ # # ]: 0 : bridge->get_simple_attribute("DEFERRED_ATTRIB", others);
[ # # ]
1207 [ # # ][ # # ]: 0 : while ( others.size() )
1208 : : {
1209 [ # # ]: 0 : CubitSimpleAttrib dup_attrib = others.pop();
1210 [ # # ][ # # ]: 0 : if ( dup_attrib.string_data_list()[1] == real_name )
[ # # ][ # # ]
1211 [ # # ]: 0 : bridge->remove_simple_attribute_virt(dup_attrib);
1212 [ # # ][ # # ]: 0 : }
1213 : : }
1214 : :
1215 : : // append attribute
1216 [ + - ][ + - ]: 31522 : bridge->append_simple_attribute_virt(attrib_ptr);
1217 : 31522 : }
1218 : :
1219 : 170605 : void CubitAttribUser::remove_all_simple_attribute(TopologyBridge* bridge)
1220 : : {
1221 : : // remove this name from the primary object
1222 : 170605 : bridge->remove_all_simple_attribute_virt();
1223 : :
1224 : : // for merged objects, remove all attributes from other entities
1225 [ + - + + ]: 341210 : if (CubitSimpleAttrib::get_push_attribs() == CUBIT_TRUE ||
[ + + ]
1226 : 170605 : CGMApp::instance()->attrib_manager()->auto_update_flag(CA_MERGE_PARTNER) == CUBIT_TRUE) {
1227 [ + - ]: 90226 : DLIList<TopologyBridge*> tb_list;
1228 [ + - ][ + - ]: 90226 : bridge->bridge_manager()->get_bridge_list(tb_list);
1229 [ + - ]: 90226 : tb_list.reset();
1230 [ + - ][ + - ]: 90226 : assert(tb_list.size() == 0 || tb_list.get() == bridge);
[ + - ][ - + ]
1231 [ + - ][ + + ]: 183080 : for (int i = tb_list.size(); i > 0; i--) {
1232 [ + - ]: 92854 : TopologyBridge *temp_tb = tb_list.get_and_step();
1233 [ + + ][ + - ]: 92854 : if (temp_tb != bridge) temp_tb->remove_all_simple_attribute_virt();
1234 [ + - ]: 90226 : }
1235 : : }
1236 : 170605 : }
1237 : :
1238 : 193449 : void CubitAttribUser::remove_simple_attribute(TopologyBridge* bridge, const CubitSimpleAttrib& attrib_ptr)
1239 : : {
1240 : : // remove this name from the primary object
1241 : 193449 : bridge->remove_simple_attribute_virt(attrib_ptr);
1242 : :
1243 : : // for merged objects, remove attribute from other entities
1244 [ + - + + ]: 386898 : if (CubitSimpleAttrib::get_push_attribs() == CUBIT_TRUE ||
[ + + ]
1245 : 193449 : CGMApp::instance()->attrib_manager()->auto_update_flag(CA_MERGE_PARTNER) == CUBIT_TRUE) {
1246 [ + - ]: 125649 : DLIList<TopologyBridge*> tb_list;
1247 [ + - ]: 125649 : BridgeManager *bm_ptr = bridge->bridge_manager();
1248 [ + - ][ + - ]: 125649 : if (bm_ptr != NULL) bm_ptr->get_bridge_list(tb_list);
1249 [ + - ]: 125649 : tb_list.reset();
1250 [ + - ][ + - ]: 125649 : assert(tb_list.size() == 0 || tb_list.get() == bridge);
[ + - ][ - + ]
1251 [ + - ][ + + ]: 269406 : for (int i = tb_list.size(); i > 0; i--) {
1252 [ + - ]: 143757 : TopologyBridge *temp_tb = tb_list.get_and_step();
1253 [ + + ][ + - ]: 143757 : if (temp_tb != bridge) temp_tb->remove_simple_attribute_virt(attrib_ptr);
1254 [ + - ]: 125649 : }
1255 : : }
1256 [ + - ][ + - ]: 199989 : }
1257 : :
|
