Branch data Line data Source code
1 : : #ifndef MESHKIT_ITAPS_MESH_HPP
2 : : #define MESHKIT_ITAPS_MESH_HPP
3 : :
4 : : /** \file iMesh.hpp
5 : : */
6 : :
7 : : #include "moab/EntityType.hpp"
8 : : #include "iMesh.h"
9 : : #include "iRel.hpp"
10 : : #include <string.h>
11 : : #include <stdlib.h>
12 : : #include <vector>
13 : : #include <limits>
14 : : #include <string>
15 : :
16 : : #define ITAPS_PREFIX iMesh
17 : : #include "meshkit/iBase.hpp"
18 : : #undef ITAPS_PREFIX
19 : :
20 : : /** \class iMesh
21 : : * \brief C++ interface to ITAPS iMesh interface
22 : : *
23 : : * This class is a simple wrapper for the ITAPS iGeom interface. The primary benefit to using this class
24 : : * instead of iMesh directly is that lists of handles are passed as std::vectors instead of pointers to
25 : : * handle arrays. This file includes both declaration and definition of all iGeom class functions, i.e.
26 : : * all functions are inlined. The class can be constructed and destructed in the standard C++ way; the
27 : : * implementation of those functions call into the standard iMesh C functions newMesh and dtor.
28 : : *
29 : : * For complete documentation of these functions, see http://www.itaps.org/software/iMesh_html/index.html.
30 : : */
31 : : class iMesh : public iMeshBase {
32 : : public:
33 : : inline iRel::IfaceType iface_type() const {
34 : : return iRel::IMESH_IFACE;
35 : : }
36 : :
37 : :
38 : : /* map to MB's entity type from TSTT's entity topology */
39 : : static const moab::EntityType mb_topology_table[iMesh_ALL_TOPOLOGIES+1];
40 : :
41 : : typedef iMesh_EntityTopology EntityTopology;
42 : : typedef iBase_AdjacencyCost AdjacencyCost;
43 : :
44 : : explicit inline iMesh( const char* options = 0 );
45 : : inline iMesh( iMesh_Instance imesh );
46 : :
47 : : inline ~iMesh();
48 : :
49 : : inline Error load( EntitySetHandle set,
50 : : const char* file_name,
51 : : const char* options = 0 );
52 : :
53 : : inline Error save( EntitySetHandle set,
54 : : const char* file_name,
55 : : const char* options = 0 );
56 : :
57 : : inline int getGeometricDimension() const;
58 : :
59 : : inline Error setGeometricDimension( int dim );
60 : :
61 : : inline StorageOrder getDfltStorage() const;
62 : :
63 : : typedef AdjacencyCost (*AdjTableType)[4];
64 : : inline AdjTableType getAdjTable();
65 : :
66 : : inline Error setAdjTable( int* adj_table, int table_size);
67 : :
68 : : inline Error getNumOfType( EntitySetHandle set, EntityType type, int& count_out ) const;
69 : :
70 : : inline Error getNumOfTopo( EntitySetHandle set, EntityTopology topo, int& count_out ) const;
71 : :
72 : : inline bool optimize();
73 : :
74 : : inline Error getEntities( EntitySetHandle set,
75 : : EntityType type,
76 : : EntityTopology topo,
77 : : std::vector<EntityHandle>& entities_out ) const;
78 : :
79 : : inline Error getVtxCoord( EntityHandle vertex, double& x, double& y, double& z ) const;
80 : : inline Error setVtxCoord( EntityHandle vertex, double x, double y, double z );
81 : :
82 : :
83 : : inline Error getVtxArrCoords( const EntityHandle* vertex_handles,
84 : : int vertex_handles_size,
85 : : StorageOrder storage_order,
86 : : double* coords_out ) const;
87 : :
88 : : inline Error setVtxArrCoords( const EntityHandle* vertex_handles,
89 : : int vertex_handles_size,
90 : : StorageOrder storage_order,
91 : : const double* new_coords );
92 : :
93 : : inline Error createVtx( double x, double y, double z, EntityHandle& vertex_out );
94 : :
95 : : inline Error createVtxArr( int num_verts,
96 : : StorageOrder storage_order,
97 : : const double* new_coords,
98 : : EntityHandle* new_vertex_handles_out );
99 : :
100 : : inline Error createEnt( EntityTopology topology,
101 : : const EntityHandle* lower_order_entity_handles,
102 : : int lower_order_entity_handles_size,
103 : : EntityHandle& new_entity_handle_out );
104 : :
105 : : inline Error createEntArr( EntityTopology new_entity_topology,
106 : : const EntityHandle* lower_order_entity_handles,
107 : : int lower_order_entity_handles_size,
108 : : EntityHandle* new_entity_handles_out );
109 : :
110 : : inline Error deleteEnt( EntityHandle handle );
111 : :
112 : : inline Error deleteEntArr( const EntityHandle* entity_handles, int num_handles );
113 : :
114 : : inline Error getAdjEntities( EntitySetHandle set,
115 : : EntityType type_requestor,
116 : : EntityTopology topo_requestor,
117 : : EntityType type_requested,
118 : : std::vector<EntityHandle>& adj_entity_handles,
119 : : std::vector<int>& offset ) const;
120 : :
121 : : /** \class EntArrIter iMesh.hpp "iMesh.hpp"
122 : : * \brief Class for iterating over %iMesh entity arrays.
123 : : */
124 : : class EntArrIter {
125 : : private:
126 : : friend class iMesh;
127 : : iBase_EntityArrIterator mHandle;
128 : : iMesh_Instance mInstance;
129 : : int mSize;
130 : : public:
131 : : EntArrIter() : mHandle(0), mInstance(0), mSize(0) {}
132 : : inline ~EntArrIter();
133 : : inline Error getNext( EntityHandle* entity_handles_out,
134 : : int& size_out,
135 : : bool& has_more_data_out );
136 : : inline Error reset();
137 : : };
138 : :
139 : : /** \class EntIter iMesh.hpp "iMesh.hpp"
140 : : * \brief Class for iterating over %iMesh entities.
141 : : */
142 : : class EntIter {
143 : : private:
144 : : friend class iMesh;
145 : : iBase_EntityIterator mHandle;
146 : : iMesh_Instance mInstance;
147 : : public:
148 : : EntIter() : mHandle(0), mInstance(0) {}
149 : : inline ~EntIter();
150 : : inline Error getNext( EntityHandle& entity_handle_out,
151 : : bool& has_more_data_out );
152 : : inline Error reset();
153 : : };
154 : :
155 : : inline Error initEntIter( EntitySetHandle set,
156 : : EntityType requested_type,
157 : : EntityTopology requested_topo,
158 : : int resilient,
159 : : EntIter& iter );
160 : : inline Error initEntArrIter( EntitySetHandle set,
161 : : EntityType requested_type,
162 : : EntityTopology requested_topo,
163 : : int requested_array_size,
164 : : int resilient,
165 : : EntArrIter& iter );
166 : :
167 : : inline Error getEntTopo( EntityHandle handle, EntityTopology& topo_out ) const;
168 : : inline Error getEntArrTopo( const EntityHandle* entity_handles,
169 : : int entity_handles_Size,
170 : : EntityTopology* topos_out ) const;
171 : :
172 : : inline Error getEntType( EntityHandle handle, EntityType& type_out ) const;
173 : : inline Error getEntArrType( const EntityHandle* entity_handles,
174 : : int entity_handles_Size,
175 : : EntityType* types_out ) const;
176 : :
177 : : inline Error getEntAdj( EntityHandle handle,
178 : : EntityType type_requested,
179 : : std::vector<EntityHandle>& adj_entities_out ) const;
180 : : inline Error getEntArrAdj( const EntityHandle* entity_handles,
181 : : int entity_handles_size,
182 : : EntityType type_requested,
183 : : std::vector<EntityHandle>& adjacent_entity_handles_out,
184 : : int* offsets_out ) const ;
185 : :
186 : : inline Error getEnt2ndAdj( EntityHandle handle,
187 : : EntityType bridge_entity_type,
188 : : EntityType type_requested,
189 : : std::vector<EntityHandle>& adj_entities_out ) const;
190 : : inline Error getEntArr2ndAdj( const EntityHandle* entity_handles,
191 : : int entity_handles_size,
192 : : EntityType order_key,
193 : : EntityType type_requested,
194 : : std::vector<EntityHandle>& adjacent_entity_handles_out,
195 : : int* offsets_out ) const;
196 : :
197 : : inline Error getAdjEntIndices( EntitySetHandle set,
198 : : EntityType requestor_type,
199 : : EntityTopology requestor_topo,
200 : : EntityType type_requested,
201 : : std::vector<EntityHandle>& entity_handles_out,
202 : : std::vector<EntityHandle>& adj_entity_handles_out,
203 : : std::vector<int>& adj_entity_indices_out,
204 : : std::vector<int>& offsets_out ) const;
205 : :
206 : : private:
207 : : bool iMeshInstanceOwner;
208 : : AdjacencyCost adjTable[4][4];
209 : : Error adjTableErr;
210 : :
211 : : void cacheAdjTable();
212 : :
213 : : // prohibit copying
214 : : iMesh( const iMesh& ) {}
215 : : void operator=(const iMesh&) {}
216 : : };
217 : :
218 : : inline void
219 : 132 : iMesh::cacheAdjTable()
220 : : {
221 : : int err;
222 : : if (sizeof(int) == sizeof(AdjacencyCost)) {
223 : 66 : int* ptr = (int*)&adjTable[0][0];
224 : 66 : int size = 16, alloc = 16;
225 [ + - ]: 66 : iMesh_getAdjTable( mInstance, &ptr, &alloc, &size, &err );
226 : 66 : adjTableErr = (Error)err;
227 : : }
228 : : else {
229 : : int data[16];
230 : : int* ptr = data;
231 : : int size = 16, alloc = 16;
232 : : iMesh_getAdjTable( mInstance, &ptr, &alloc, &size, &err );
233 : : adjTableErr = (Error)err;
234 : : for (int i = 0; i < 4; ++i)
235 : : for (int j = 0; j < 4; ++j)
236 : : adjTable[i][j] = (AdjacencyCost)data[4*i+1];
237 : : }
238 : 66 : }
239 : :
240 : : inline
241 : : iMesh::iMesh( const char* options )
242 : : {
243 : : int err, len = options ? strlen(options) : 0;
244 : : iMesh_newMesh( options, &mInstance, &err, len );
245 : : if (iBase_SUCCESS != err) {
246 : : mInstance = 0;
247 : : iMeshInstanceOwner = false;
248 : : }
249 : : else {
250 : : iMeshInstanceOwner = true;
251 : : cacheAdjTable();
252 : : }
253 : : }
254 : :
255 : : inline
256 : 65 : iMesh::iMesh( iMesh_Instance instance )
257 : 65 : : iMeshInstanceOwner(false)
258 : : {
259 : 65 : mInstance = instance;
260 : 65 : cacheAdjTable();
261 : 65 : }
262 : :
263 : 48 : inline iMesh::~iMesh()
264 : : {
265 [ - + ]: 48 : if (iMeshInstanceOwner) {
266 : : int err;
267 : 0 : iMesh_dtor( mInstance, &err );
268 : : }
269 : 48 : }
270 : :
271 : : inline iMesh::Error
272 : 2 : iMesh::load( EntitySetHandle set,
273 : : const char* file_name,
274 : : const char* options )
275 : : {
276 [ - + ]: 2 : int err, len = options ? strlen(options) : 0;
277 [ + - ]: 2 : iMesh_load( mInstance, set, file_name, options, &err, strlen(file_name), len );
278 : 2 : return (Error)err;
279 : : }
280 : :
281 : :
282 : : inline iMesh::Error
283 : : iMesh::save( EntitySetHandle set,
284 : : const char* file_name,
285 : : const char* options )
286 : : {
287 : : int err, len = options ? strlen(options) : 0;
288 : : iMesh_save( mInstance, set, file_name, options, &err, strlen(file_name), len );
289 : : return (Error)err;
290 : : }
291 : :
292 : :
293 : : inline int
294 : 28 : iMesh::getGeometricDimension() const
295 : : {
296 : : int err, result;
297 [ + - ]: 28 : iMesh_getGeometricDimension( mInstance, &result, &err );
298 [ - + ]: 28 : return iBase_SUCCESS == err ? result : -err;
299 : : }
300 : :
301 : :
302 : : inline iMesh::Error
303 : : iMesh::setGeometricDimension( int dim )
304 : : {
305 : : int err;
306 : : iMesh_setGeometricDimension( mInstance, dim, &err );
307 : : return (Error)err;
308 : : }
309 : :
310 : : inline iMesh::StorageOrder
311 : : iMesh::getDfltStorage() const
312 : : {
313 : : int err, order;
314 : : iMesh_getDfltStorage( mInstance, &order, &err );
315 : : return (iBase_SUCCESS == err) ? (StorageOrder)order : iBase_BLOCKED;
316 : : }
317 : :
318 : 1 : inline iMesh::AdjTableType iMesh::getAdjTable()
319 : : {
320 : 1 : cacheAdjTable(); //retrieve the most up-to-date table
321 [ + - ]: 1 : return (iBase_SUCCESS == adjTableErr) ? adjTable : 0;
322 : : }
323 : :
324 : :
325 : : inline iMesh::Error
326 : 2 : iMesh::setAdjTable( int adj_table[], int table_size)
327 : : {
328 : :
329 : : int err;
330 [ + - ]: 2 : iMesh_setAdjTable( mInstance, adj_table, table_size, &err);
331 : :
332 : 2 : return (Error)err;
333 : :
334 : : }
335 : :
336 : : inline iMesh::Error
337 : 1205 : iMesh::getNumOfType( EntitySetHandle set, EntityType type, int& count_out ) const
338 : : {
339 : : int err;
340 [ + - ]: 1205 : iMesh_getNumOfType( mInstance, set, type, &count_out, &err );
341 : 1205 : return (Error)err;
342 : : }
343 : :
344 : : inline iMesh::Error
345 : 95 : iMesh::getNumOfTopo( EntitySetHandle set, EntityTopology topo, int& count_out ) const
346 : : {
347 : : int err;
348 [ + - ]: 95 : iMesh_getNumOfTopo( mInstance, set, topo, &count_out, &err );
349 : 95 : return (Error)err;
350 : : }
351 : :
352 : : inline bool
353 : : iMesh::optimize()
354 : : {
355 : : int err, result;
356 : : iMesh_optimize( mInstance, &result, &err );
357 : : return (iBase_SUCCESS == err) ? !!result : true;
358 : : }
359 : :
360 : : inline iMesh::Error
361 : 184 : iMesh::getEntities( EntitySetHandle set,
362 : : EntityType type,
363 : : EntityTopology topo,
364 : : std::vector<EntityHandle>& entities_out ) const
365 : : {
366 : : // if input vect has no allocated space, allocate some so
367 : : // we don't accidentally ask the impl to allocate an array
368 [ + + ]: 184 : if (entities_out.capacity() == 0) {
369 : : Error err2;
370 : : int count;
371 [ + + ]: 172 : if (topo == iMesh_ALL_TOPOLOGIES)
372 [ + - ]: 83 : err2 = getNumOfType( set, type, count );
373 : : else
374 [ + - ]: 89 : err2 = getNumOfTopo( set, topo, count );
375 [ - + ]: 172 : if (err2 != iBase_SUCCESS)
376 : 0 : return err2;
377 [ + - ]: 172 : entities_out.resize( count );
378 : : }
379 : :
380 : : // try getting results using whatever space input vector has allocated
381 : 184 : int err, size = 0, alloc = entities_out.capacity();
382 [ + - ]: 184 : entities_out.resize( entities_out.capacity() );
383 [ + - ]: 184 : EntityHandle* ptr = &entities_out[0];
384 [ + - ]: 184 : iMesh_getEntities( mInstance, set, type, topo, &ptr, &alloc, &size, &err );
385 [ + - ]: 184 : entities_out.resize(size);
386 : :
387 : : // if input vector was too small, try again with increased size
388 [ + - ][ - + ]: 184 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
389 : 0 : alloc = entities_out.size();
390 [ # # ]: 0 : ptr = &entities_out[0];
391 [ # # ]: 0 : iMesh_getEntities( mInstance, set, type, topo, &ptr, &alloc, &size, &err );
392 : : }
393 : :
394 : 184 : return (Error)err;
395 : : }
396 : :
397 : : inline iMesh::Error
398 : 14382 : iMesh::getVtxCoord( EntityHandle vertex, double& x, double& y, double& z ) const
399 : : {
400 : : int err;
401 [ + - ]: 14382 : iMesh_getVtxCoord( mInstance, vertex, &x, &y, &z, &err );
402 : 14382 : return (Error)err;
403 : : }
404 : :
405 : : inline iMesh::Error
406 : 0 : iMesh::setVtxCoord( EntityHandle vertex, double x, double y, double z )
407 : : {
408 : : int err;
409 [ # # ]: 0 : iMesh_setVtxCoord( mInstance, vertex, x, y, z, &err );
410 : 0 : return (Error)err;
411 : : }
412 : :
413 : :
414 : : inline iMesh::Error
415 : 104 : iMesh::getVtxArrCoords( const EntityHandle* vertex_handles,
416 : : int vertex_handles_size,
417 : : StorageOrder storage_order,
418 : : double* coords_out ) const
419 : : {
420 : 104 : int err, alloc = 3*vertex_handles_size, junk, order = storage_order;
421 : : iMesh_getVtxArrCoords( mInstance, vertex_handles, vertex_handles_size,
422 [ + - ]: 104 : order, &coords_out, &alloc, &junk, &err );
423 : 104 : return (Error)err;
424 : : }
425 : :
426 : : inline iMesh::Error
427 : 0 : iMesh::setVtxArrCoords( const EntityHandle* vertex_handles,
428 : : int vertex_handles_size,
429 : : StorageOrder storage_order,
430 : : const double* new_coords )
431 : : {
432 [ # # ]: 0 : int err, dim = getGeometricDimension();
433 : : iMesh_setVtxArrCoords( mInstance, vertex_handles, vertex_handles_size,
434 : : storage_order, new_coords, dim*vertex_handles_size,
435 [ # # ]: 0 : &err );
436 : 0 : return (Error)err;
437 : : }
438 : :
439 : : inline iMesh::Error
440 : 8215 : iMesh::createVtx( double x, double y, double z, EntityHandle& vertex_out )
441 : : {
442 : : int err;
443 [ + - ]: 8215 : iMesh_createVtx( mInstance, x, y, z, &vertex_out, &err );
444 : 8215 : return (Error)err;
445 : : }
446 : :
447 : :
448 : : inline iMesh::Error
449 : 28 : iMesh::createVtxArr( int num_verts,
450 : : StorageOrder storage_order,
451 : : const double* new_coords,
452 : : EntityHandle* new_vertex_handles_out )
453 : : {
454 [ + - ]: 28 : int err, alloc = num_verts, junk, dim = getGeometricDimension();
455 : : iMesh_createVtxArr( mInstance, num_verts, storage_order, new_coords,
456 : : dim * num_verts, &new_vertex_handles_out,
457 [ + - ]: 28 : &alloc, &junk, &err );
458 : 28 : return (Error)err;
459 : : }
460 : :
461 : : inline iMesh::Error
462 : 9173 : iMesh::createEnt( EntityTopology topology,
463 : : const EntityHandle* entities,
464 : : int entities_size,
465 : : EntityHandle& new_entity_out )
466 : : {
467 : : int err, status;
468 [ + - ]: 9173 : iMesh_createEnt( mInstance, topology, entities, entities_size, &new_entity_out, &status, &err );
469 [ + - ]: 9173 : if (err == iBase_SUCCESS)
470 [ + - ][ - + ]: 9173 : if (status == iBase_ALREADY_EXISTED || status == iBase_CREATION_FAILED)
471 : 9173 : err = iBase_ENTITY_CREATION_ERROR;
472 : 9173 : return (Error)err;
473 : : }
474 : :
475 : : inline iMesh::Error
476 : 17 : iMesh::createEntArr( EntityTopology new_entity_topology,
477 : : const EntityHandle* lower_order_handles,
478 : : int lower_order_handles_size,
479 : : EntityHandle* new_entity_handles_out )
480 : : {
481 [ + - ]: 17 : std::vector<int> status(lower_order_handles_size, iBase_CREATION_FAILED);
482 : 17 : int err, alloc = lower_order_handles_size, size = 0;
483 [ + - ]: 17 : int status_alloc = status.size(), junk, *stat_ptr = &status[0];
484 : :
485 : : iMesh_createEntArr( mInstance, new_entity_topology,
486 : : lower_order_handles, lower_order_handles_size,
487 : : &new_entity_handles_out, &alloc, &size,
488 [ + - ]: 17 : &stat_ptr, &status_alloc, &junk, &err );
489 : :
490 [ + - ]: 17 : if (iBase_SUCCESS == err) {
491 [ + + ]: 1007 : for (int i = 0; i < size; ++i)
492 [ + - ][ - + ]: 990 : if (status[i] != iBase_NEW && status[i] != iBase_CREATED_DUPLICATE)
[ # # ][ # # ]
[ - + ]
493 : 0 : err = iBase_ENTITY_CREATION_ERROR;
494 : : }
495 : :
496 [ - + ]: 17 : if (iBase_SUCCESS != err) {
497 : 0 : int err2, w = 0;
498 [ # # ]: 0 : for (int r = 0; r < size; ++r)
499 [ # # ][ # # ]: 0 : if (status[r] == iBase_NEW || status[r] == iBase_CREATED_DUPLICATE)
[ # # ][ # # ]
[ # # ]
500 : 0 : new_entity_handles_out[w++] = new_entity_handles_out[r];
501 [ # # ]: 0 : iMesh_deleteEntArr( mInstance, new_entity_handles_out, w, &err2 );
502 : : }
503 : :
504 : 17 : return (Error)err;
505 : : }
506 : :
507 : : inline iMesh::Error
508 : 120 : iMesh::deleteEnt( EntityHandle handle )
509 : : {
510 : : int err;
511 [ + - ]: 120 : iMesh_deleteEnt( mInstance, handle, &err );
512 : 120 : return (Error)err;
513 : : }
514 : :
515 : : inline iMesh::Error
516 : 3 : iMesh::deleteEntArr( const EntityHandle* entity_handles, int num_handles )
517 : : {
518 : : int err;
519 [ + - ]: 3 : iMesh_deleteEntArr( mInstance, entity_handles, num_handles, &err );
520 : 3 : return (Error)err;
521 : : }
522 : :
523 : : inline iMesh::Error
524 : 8 : iMesh::getAdjEntities( EntitySetHandle set,
525 : : EntityType type_requestor,
526 : : EntityTopology topo_requestor,
527 : : EntityType type_requested,
528 : : std::vector<EntityHandle>& adj_entity_handles,
529 : : std::vector<int>& offset ) const
530 : : {
531 [ + - ]: 8 : std::vector<EntityHandle> entities;
532 [ + - ]: 8 : Error err = getEntities( set, type_requestor, topo_requestor, entities );
533 [ - + ]: 8 : if (iBase_SUCCESS != err)
534 : 0 : return err;
535 : :
536 [ + - ]: 8 : offset.resize( entities.size() + 1 );
537 [ + - ]: 8 : return getEntArrAdj( &entities[0], entities.size(), type_requested,
538 [ + - ][ + - ]: 16 : adj_entity_handles, &offset[0] );
539 : : }
540 : :
541 : : inline iMesh::Error
542 : : iMesh::initEntIter( EntitySetHandle set,
543 : : EntityType requested_type,
544 : : EntityTopology requested_topo,
545 : : int resilient,
546 : : iMesh::EntIter& iter )
547 : : {
548 : : int err;
549 : : iter.mInstance = mInstance;
550 : : iMesh_initEntIter( mInstance, set, requested_type, requested_topo, resilient,
551 : : &iter.mHandle, &err );
552 : : return (Error)err;
553 : : }
554 : :
555 : : inline iMesh::Error
556 : : iMesh::initEntArrIter( EntitySetHandle set,
557 : : EntityType requested_type,
558 : : EntityTopology requested_topo,
559 : : int requested_array_size,
560 : : int resilient,
561 : : iMesh::EntArrIter& iter )
562 : : {
563 : : int err;
564 : : iter.mInstance = mInstance;
565 : : iter.mSize = requested_array_size;
566 : : iMesh_initEntArrIter( mInstance, set, requested_type, requested_topo,
567 : : requested_array_size, resilient, &iter.mHandle, &err );
568 : : return (Error)err;
569 : : }
570 : :
571 : : inline
572 : : iMesh::EntArrIter::~EntArrIter()
573 : : {
574 : : int err;
575 : : if (mHandle != 0) {
576 : : iMesh_endEntArrIter( mInstance, mHandle, &err );
577 : : mHandle = 0;
578 : : }
579 : : }
580 : :
581 : : inline
582 : : iMesh::EntIter::~EntIter()
583 : : {
584 : : int err;
585 : : if (mHandle != 0) {
586 : : iMesh_endEntIter( mInstance, mHandle, &err );
587 : : mHandle = 0;
588 : : }
589 : : }
590 : :
591 : : inline iMesh::Error
592 : : iMesh::EntArrIter::getNext( EntityHandle* entity_handles,
593 : : int& size_out,
594 : : bool& has_more_data_out )
595 : : {
596 : : int err, alloc = mSize, has_data;
597 : : iMesh_getNextEntArrIter( mInstance, mHandle, &entity_handles, &alloc,
598 : : &size_out, &has_data, &err );
599 : : has_more_data_out = (has_data != 0);
600 : : return (Error)err;
601 : : }
602 : :
603 : : inline iMesh::Error
604 : : iMesh::EntIter::getNext( EntityHandle& handle_out, bool& has_more_data_out )
605 : : {
606 : : int err, has_data;
607 : : iMesh_getNextEntIter( mInstance, mHandle, &handle_out, &has_data, &err );
608 : : has_more_data_out = (has_data != 0);
609 : : return (Error)err;
610 : : }
611 : :
612 : : inline iMesh::Error
613 : : iMesh::EntArrIter::reset()
614 : : {
615 : : int err;
616 : : iMesh_resetEntArrIter( mInstance, mHandle, &err );
617 : : return (Error)err;
618 : : }
619 : :
620 : : inline iMesh::Error
621 : : iMesh::EntIter::reset()
622 : : {
623 : : int err;
624 : : iMesh_resetEntIter( mInstance, mHandle, &err );
625 : : return (Error)err;
626 : : }
627 : :
628 : : inline iMesh::Error
629 : 72 : iMesh::getEntTopo( EntityHandle handle, EntityTopology& topo_out ) const
630 : : {
631 : : int err, result;
632 [ + - ]: 72 : iMesh_getEntTopo( mInstance, handle, &result, &err );
633 : 72 : topo_out = (EntityTopology)result;
634 : 72 : return (Error)err;
635 : : }
636 : :
637 : : inline iMesh::Error
638 : 7 : iMesh::getEntArrTopo( const EntityHandle* entity_handles,
639 : : int entity_handles_size,
640 : : EntityTopology* topos_out ) const
641 : : {
642 : 7 : int err, alloc = entity_handles_size, junk, *ptr;
643 [ + - ]: 7 : std::vector<int> storage;
644 : : if (sizeof(EntityTopology) == sizeof(int))
645 : 7 : ptr = reinterpret_cast<int*>(topos_out);
646 : : else {
647 : : storage.resize( entity_handles_size );
648 : : ptr = &storage[0];
649 : : }
650 : :
651 : : iMesh_getEntArrTopo( mInstance, entity_handles, entity_handles_size,
652 [ + - ]: 7 : &ptr, &alloc, &junk, &err );
653 : :
654 : : if (sizeof(EntityTopology) != sizeof(int))
655 : : for (int i = 0; i < entity_handles_size; ++i)
656 : : topos_out[i] = (EntityTopology)storage[i];
657 : :
658 : 7 : return (Error)err;
659 : : }
660 : :
661 : : inline iMesh::Error
662 : 4 : iMesh::getEntType( EntityHandle handle, EntityType& type_out ) const
663 : : {
664 : : int err, result;
665 [ + - ]: 4 : iMesh_getEntType( mInstance, handle, &result, &err );
666 : 4 : type_out = (EntityType)result;
667 : 4 : return (Error)err;
668 : : }
669 : :
670 : : inline iMesh::Error
671 : : iMesh::getEntArrType( const EntityHandle* entity_handles,
672 : : int entity_handles_size,
673 : : EntityType* types_out ) const
674 : : {
675 : : int err, alloc = entity_handles_size, junk, *ptr;
676 : : std::vector<int> storage;
677 : : if (sizeof(EntityType) == sizeof(int))
678 : : ptr = reinterpret_cast<int*>(types_out);
679 : : else {
680 : : storage.resize( entity_handles_size );
681 : : ptr = &storage[0];
682 : : }
683 : :
684 : : iMesh_getEntArrType( mInstance, entity_handles, entity_handles_size,
685 : : &ptr, &alloc, &junk, &err );
686 : :
687 : : if (sizeof(EntityType) != sizeof(int))
688 : : for (int i = 0; i < entity_handles_size; ++i)
689 : : types_out[i] = (EntityType)storage[i];
690 : :
691 : : return (Error)err;
692 : : }
693 : :
694 : : inline iMesh::Error
695 : 980 : iMesh::getEntAdj( EntityHandle handle,
696 : : EntityType type_requested,
697 : : std::vector<EntityHandle>& adj_entities_out ) const
698 : : {
699 [ + + ]: 980 : if (adj_entities_out.capacity() == 0)
700 [ + - ]: 976 : adj_entities_out.resize(12);
701 : : else
702 [ + - ]: 4 : adj_entities_out.resize( adj_entities_out.capacity() );
703 : :
704 : 980 : int err, alloc = adj_entities_out.size(), size = 0;
705 [ + - ]: 980 : EntityHandle* ptr = &adj_entities_out[0];
706 : : iMesh_getEntAdj( mInstance, handle, type_requested,
707 [ + - ]: 980 : &ptr, &alloc, &size, &err );
708 [ + - ]: 980 : adj_entities_out.resize(size);
709 : :
710 [ + - ][ - + ]: 980 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
711 : 0 : alloc = adj_entities_out.size();
712 [ # # ]: 0 : ptr = &adj_entities_out[0];
713 : : iMesh_getEntAdj( mInstance, handle, type_requested,
714 [ # # ]: 0 : &ptr, &alloc, &size, &err );
715 : : }
716 : :
717 : 980 : return (Error)err;
718 : : }
719 : :
720 : : inline iMesh::Error
721 : 23 : iMesh::getEntArrAdj( const EntityHandle* entity_handles,
722 : : int entity_handles_size,
723 : : EntityType type_requested,
724 : : std::vector<EntityHandle>& adj_entities_out,
725 : : int* offsets_out ) const
726 : : {
727 [ + - ]: 23 : if (adj_entities_out.capacity() == 0)
728 [ + - ]: 23 : adj_entities_out.resize(12*entity_handles_size);
729 : : else
730 [ # # ]: 0 : adj_entities_out.resize( adj_entities_out.capacity() );
731 : :
732 : 23 : int err, alloc = adj_entities_out.size(), size = 0;
733 : 23 : int off_alloc = entity_handles_size+1, junk;
734 [ + - ]: 23 : EntityHandle* ptr = &adj_entities_out[0];
735 : : iMesh_getEntArrAdj( mInstance, entity_handles, entity_handles_size,
736 : : type_requested,
737 : : &ptr, &alloc, &size,
738 : : &offsets_out, &off_alloc, &junk,
739 [ + - ]: 23 : &err );
740 [ + - ]: 23 : adj_entities_out.resize(size);
741 : :
742 [ + - ][ - + ]: 23 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
743 : 0 : alloc = adj_entities_out.size();
744 [ # # ]: 0 : ptr = &adj_entities_out[0];
745 : : iMesh_getEntArrAdj( mInstance, entity_handles, entity_handles_size,
746 : : type_requested,
747 : : &ptr, &alloc, &size,
748 : : &offsets_out, &off_alloc, &junk,
749 [ # # ]: 0 : &err );
750 : : }
751 : :
752 : 23 : return (Error)err;
753 : : }
754 : :
755 : :
756 : : inline iMesh::Error
757 : 16 : iMesh::getEnt2ndAdj( EntityHandle handle,
758 : : EntityType bridge_entity_type,
759 : : EntityType type_requested,
760 : : std::vector<EntityHandle>& adj_entities_out ) const
761 : : {
762 [ + - ]: 16 : if (adj_entities_out.capacity() == 0)
763 [ + - ]: 16 : adj_entities_out.resize(12);
764 : : else
765 [ # # ]: 0 : adj_entities_out.resize( adj_entities_out.capacity() );
766 : :
767 : 16 : int err, alloc = adj_entities_out.size(), size = 0;
768 [ + - ]: 16 : EntityHandle* ptr = &adj_entities_out[0];
769 : : iMesh_getEnt2ndAdj( mInstance, handle, bridge_entity_type, type_requested,
770 [ + - ]: 16 : &ptr, &alloc, &size, &err );
771 [ + - ]: 16 : adj_entities_out.resize(size);
772 : :
773 [ + - ][ - + ]: 16 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
774 : 0 : alloc = adj_entities_out.size();
775 [ # # ]: 0 : ptr = &adj_entities_out[0];
776 : : iMesh_getEnt2ndAdj( mInstance, handle, bridge_entity_type, type_requested,
777 [ # # ]: 0 : &ptr, &alloc, &size, &err );
778 : : }
779 : :
780 : 16 : return (Error)err;
781 : : }
782 : :
783 : : inline iMesh::Error
784 : : iMesh::getEntArr2ndAdj( const EntityHandle* entity_handles,
785 : : int entity_handles_size,
786 : : EntityType order_key,
787 : : EntityType type_requested,
788 : : std::vector<EntityHandle>& adj_entities_out,
789 : : int* offsets_out ) const
790 : : {
791 : : if (adj_entities_out.capacity() == 0)
792 : : adj_entities_out.resize(12*entity_handles_size);
793 : : else
794 : : adj_entities_out.resize( adj_entities_out.capacity() );
795 : :
796 : : int err, alloc = adj_entities_out.size(), size = 0;
797 : : int off_alloc = entity_handles_size+1, junk;
798 : : EntityHandle* ptr = &adj_entities_out[0];
799 : : iMesh_getEntArr2ndAdj( mInstance, entity_handles, entity_handles_size,
800 : : order_key, type_requested,
801 : : &ptr, &alloc, &size,
802 : : &offsets_out, &off_alloc, &junk,
803 : : &err );
804 : : adj_entities_out.resize(size);
805 : :
806 : : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
807 : : alloc = adj_entities_out.size();
808 : : ptr = &adj_entities_out[0];
809 : : iMesh_getEntArr2ndAdj( mInstance, entity_handles, entity_handles_size,
810 : : order_key, type_requested,
811 : : &ptr, &alloc, &size,
812 : : &offsets_out, &off_alloc, &junk,
813 : : &err );
814 : : }
815 : :
816 : : return (Error)err;
817 : : }
818 : :
819 : :
820 : : inline iMesh::Error
821 : 12 : iMesh::getAdjEntIndices( EntitySetHandle set,
822 : : EntityType requestor_type,
823 : : EntityTopology requestor_topo,
824 : : EntityType type_requested,
825 : : std::vector<EntityHandle>& entities_out,
826 : : std::vector<EntityHandle>& adj_entities_out,
827 : : std::vector<int>& adj_indices_out,
828 : : std::vector<int>& offsets_out ) const
829 : : {
830 : : // if input vects have no allocated space, allocate some so
831 : : // we don't accidentally ask the impl to allocate an array
832 [ + - ]: 12 : if (entities_out.capacity() == 0) {
833 : : Error err2;
834 : : int count;
835 [ + - ]: 12 : if (requestor_topo == iMesh_ALL_TOPOLOGIES)
836 [ + - ]: 12 : err2 = getNumOfType( set, requestor_type, count );
837 : : else
838 [ # # ]: 0 : err2 = getNumOfTopo( set, requestor_topo, count );
839 [ - + ]: 12 : if (err2 != iBase_SUCCESS)
840 : 0 : return err2;
841 [ + - ]: 12 : entities_out.resize( count );
842 : : }
843 : : else
844 [ # # ]: 0 : entities_out.resize( entities_out.capacity() );
845 : :
846 [ + - ]: 12 : if (adj_entities_out.capacity() == 0)
847 [ + - ]: 12 : adj_entities_out.resize( 12*entities_out.size() );
848 : : else
849 [ # # ]: 0 : adj_entities_out.resize( adj_entities_out.capacity() );
850 : :
851 [ + - ]: 12 : if (adj_indices_out.capacity() == 0)
852 [ + - ]: 12 : adj_indices_out.resize( 12*entities_out.size() );
853 : : else
854 [ # # ]: 0 : adj_indices_out.resize( adj_indices_out.capacity() );
855 : :
856 [ + - ]: 12 : if (offsets_out.capacity() == 0)
857 [ + - ]: 12 : offsets_out.resize( entities_out.size() + 1 );
858 : : else
859 [ # # ]: 0 : offsets_out.resize( offsets_out.capacity() );
860 : :
861 : : int err;
862 : 12 : int entities_size = 0, entities_alloc = entities_out.size();
863 : 12 : int adj_entities_size = 0, adj_entities_alloc = adj_entities_out.size();
864 : 12 : int adj_indices_size = 0, adj_indices_alloc = adj_indices_out.size();
865 : 12 : int offsets_size = 0, offsets_alloc = offsets_out.size();
866 [ + - ]: 12 : EntityHandle* entities_ptr = & entities_out[0];
867 [ + - ]: 12 : EntityHandle* adj_entities_ptr = &adj_entities_out[0];
868 [ + - ]: 12 : int * adj_indices_ptr = & adj_indices_out[0];
869 [ + - ]: 12 : int * offsets_ptr = & offsets_out[0];
870 : :
871 : : iMesh_getAdjEntIndices( mInstance,
872 : : set, requestor_type, requestor_topo,
873 : : type_requested,
874 : : & entities_ptr, & entities_alloc, & entities_size,
875 : : &adj_entities_ptr, &adj_entities_alloc, &adj_entities_size,
876 : : & adj_indices_ptr, & adj_indices_alloc, & adj_indices_size,
877 : : & offsets_ptr, & offsets_alloc, & offsets_size,
878 [ + - ]: 12 : &err );
879 : :
880 [ + - ]: 12 : entities_out.resize( entities_size );
881 [ + - ]: 12 : adj_entities_out.resize( adj_entities_size );
882 [ + - ]: 12 : adj_indices_out.resize( adj_indices_size );
883 [ + - ]: 12 : offsets_out.resize( offsets_size );
884 : :
885 [ + - ][ - + ]: 12 : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
886 : 0 : entities_alloc = entities_out.size();
887 : 0 : adj_entities_alloc = adj_entities_out.size();
888 : 0 : adj_indices_alloc = adj_indices_out.size();
889 : 0 : offsets_alloc = offsets_out.size();
890 [ # # ]: 0 : entities_ptr = & entities_out[0];
891 [ # # ]: 0 : adj_entities_ptr = &adj_entities_out[0];
892 [ # # ]: 0 : adj_indices_ptr = & adj_indices_out[0];
893 [ # # ]: 0 : offsets_ptr = & offsets_out[0];
894 : :
895 : : iMesh_getAdjEntIndices( mInstance,
896 : : set, requestor_type, requestor_topo,
897 : : type_requested,
898 : : & entities_ptr, & entities_alloc, & entities_size,
899 : : &adj_entities_ptr, &adj_entities_alloc, &adj_entities_size,
900 : : & adj_indices_ptr, & adj_indices_alloc, & adj_indices_size,
901 : : & offsets_ptr, & offsets_alloc, & offsets_size,
902 [ # # ]: 0 : &err );
903 : : }
904 : :
905 : 12 : return (Error)err;
906 : : }
907 : :
908 : : #endif
909 : :
|
