MeshKit  1.0
iMesh.hpp
Go to the documentation of this file.
00001 #ifndef MESHKIT_ITAPS_MESH_HPP
00002 #define MESHKIT_ITAPS_MESH_HPP
00003 
00007 #include "moab/EntityType.hpp"
00008 #include "iMesh.h"
00009 #include "iRel.hpp"
00010 #include <string.h>
00011 #include <stdlib.h>
00012 #include <vector>
00013 #include <limits>
00014 #include <string>
00015 
00016 #define ITAPS_PREFIX iMesh
00017 #include "meshkit/iBase.hpp"
00018 #undef ITAPS_PREFIX
00019 
00031 class iMesh : public iMeshBase {
00032   public:
00033     inline iRel::IfaceType iface_type() const {
00034         return iRel::IMESH_IFACE;
00035     }
00036 
00037 
00038   /* map to MB's entity type from TSTT's entity topology */
00039   static const moab::EntityType mb_topology_table[iMesh_ALL_TOPOLOGIES+1];
00040 
00041     typedef iMesh_EntityTopology EntityTopology;
00042     typedef iBase_AdjacencyCost AdjacencyCost;
00043     
00044     explicit inline iMesh( const char* options = 0 );
00045     inline iMesh( iMesh_Instance imesh );
00046     
00047     inline ~iMesh();
00048     
00049     inline Error load( EntitySetHandle set,
00050                        const char* file_name,
00051                        const char* options = 0 );
00052 
00053     inline Error save( EntitySetHandle set,
00054                        const char* file_name,
00055                        const char* options = 0 );
00056     
00057     inline int getGeometricDimension() const;
00058     
00059     inline Error setGeometricDimension( int dim );
00060     
00061     inline StorageOrder getDfltStorage() const;
00062     
00063     typedef AdjacencyCost (*AdjTableType)[4];
00064     inline const AdjTableType getAdjTable();
00065     
00066     inline Error getNumOfType( EntitySetHandle set, EntityType type, int& count_out  ) const;
00067     
00068     inline Error getNumOfTopo( EntitySetHandle set, EntityTopology topo, int& count_out ) const;
00069     
00070     inline bool optimize();
00071     
00072     inline Error getEntities( EntitySetHandle set,
00073                               EntityType type,
00074                               EntityTopology topo,
00075                               std::vector<EntityHandle>& entities_out ) const;
00076     
00077     inline Error getVtxCoord( EntityHandle vertex, double& x, double& y, double& z ) const;
00078     inline Error setVtxCoord( EntityHandle vertex, double x, double y, double z );
00079     
00080     
00081     inline Error getVtxArrCoords( const EntityHandle* vertex_handles,
00082                                   int vertex_handles_size,
00083                                   StorageOrder storage_order,
00084                                   double* coords_out ) const;
00085     
00086     inline Error setVtxArrCoords( const EntityHandle* vertex_handles,
00087                                   int vertex_handles_size,
00088                                   StorageOrder storage_order,
00089                                   const double* new_coords );
00090     
00091     inline Error createVtx( double x, double y, double z, EntityHandle& vertex_out );
00092     
00093     inline Error createVtxArr( int num_verts, 
00094                                StorageOrder storage_order,
00095                                const double* new_coords,
00096                                EntityHandle* new_vertex_handles_out );
00097     
00098     inline Error createEnt( EntityTopology topology,
00099                             const EntityHandle* lower_order_entity_handles,
00100                             int lower_order_entity_handles_size,
00101                             EntityHandle& new_entity_handle_out );
00102     
00103     inline Error createEntArr( EntityTopology new_entity_topology,
00104                                const EntityHandle* lower_order_entity_handles,
00105                                int lower_order_entity_handles_size,
00106                                EntityHandle* new_entity_handles_out );
00107     
00108     inline Error deleteEnt( EntityHandle handle );
00109     
00110     inline Error deleteEntArr( const EntityHandle* entity_handles, int num_handles );
00111     
00112     inline Error getAdjEntities( EntitySetHandle set,
00113                                  EntityType type_requestor,
00114                                  EntityTopology topo_requestor,
00115                                  EntityType type_requested,
00116                                  std::vector<EntityHandle>& adj_entity_handles,
00117                                  std::vector<int>& offset ) const;
00118     
00122     class EntArrIter {
00123       private:
00124         friend class iMesh;
00125         iBase_EntityArrIterator mHandle;
00126         iMesh_Instance mInstance;
00127         int mSize;
00128       public:
00129         EntArrIter() : mHandle(0), mInstance(0), mSize(0) {}
00130         inline ~EntArrIter();
00131         inline Error getNext( EntityHandle* entity_handles_out,
00132                               int& size_out,
00133                               bool& has_more_data_out );
00134         inline Error reset();
00135     };
00136     
00140     class EntIter {
00141       private:
00142         friend class iMesh;
00143         iBase_EntityIterator mHandle;
00144         iMesh_Instance mInstance;
00145       public:
00146         EntIter() : mHandle(0), mInstance(0) {}
00147         inline ~EntIter();
00148         inline Error getNext( EntityHandle& entity_handle_out,
00149                               bool& has_more_data_out );
00150         inline Error reset();
00151     };
00152     
00153     inline Error initEntIter( EntitySetHandle set,
00154                               EntityType requested_type,
00155                               EntityTopology requested_topo,
00156                               int resilient,
00157                               EntIter& iter );
00158     inline Error initEntArrIter( EntitySetHandle set,
00159                                  EntityType requested_type,
00160                                  EntityTopology requested_topo,
00161                                  int requested_array_size,
00162                                  int resilient,
00163                                  EntArrIter& iter );
00164     
00165     inline Error getEntTopo( EntityHandle handle, EntityTopology& topo_out ) const;
00166     inline Error getEntArrTopo( const EntityHandle* entity_handles,
00167                                 int entity_handles_Size,
00168                                 EntityTopology* topos_out ) const;
00169      
00170     inline Error getEntType( EntityHandle handle, EntityType& type_out ) const;
00171     inline Error getEntArrType( const EntityHandle* entity_handles,
00172                                 int entity_handles_Size,
00173                                 EntityType* types_out ) const;
00174     
00175     inline Error getEntAdj( EntityHandle handle, 
00176                             EntityType type_requested,
00177                             std::vector<EntityHandle>& adj_entities_out ) const;                   
00178     inline Error getEntArrAdj( const EntityHandle* entity_handles,
00179                                int entity_handles_size,
00180                                EntityType type_requested,
00181                                std::vector<EntityHandle>& adjacent_entity_handles_out,
00182                                int* offsets_out ) const ;
00183                        
00184    inline Error getEnt2ndAdj( EntityHandle handle, 
00185                               EntityType bridge_entity_type,
00186                               EntityType type_requested,
00187                               std::vector<EntityHandle> adj_entities_out ) const;                   
00188    inline Error getEntArr2ndAdj( const EntityHandle* entity_handles,
00189                                   int entity_handles_size,
00190                                   EntityType order_key,
00191                                   EntityType type_requested,
00192                                   std::vector<EntityHandle>& adjacent_entity_handles_out,
00193                                   int* offsets_out ) const;
00194 
00195     inline Error getAdjEntIndices( EntitySetHandle set,
00196                                    EntityType requestor_type,
00197                                    EntityTopology requestor_topo,
00198                                    EntityType type_requested,
00199                                    std::vector<EntityHandle>& entity_handles_out,
00200                                    std::vector<EntityHandle>& adj_entity_handles_out,
00201                                    std::vector<int>& adj_entity_indices_out,
00202                                    std::vector<int>& offsets_out ) const;
00203     
00204   private:
00205     bool iMeshInstanceOwner;
00206     AdjacencyCost adjTable[4][4];
00207     Error adjTableErr;
00208     
00209     void cacheAdjTable();
00210     
00211       // prohibit copying
00212     iMesh( const iMesh& ) {}
00213     void operator=(const iMesh&) {}
00214 };
00215 
00216 inline void
00217 iMesh::cacheAdjTable()
00218 {
00219   int err;
00220   if (sizeof(int) == sizeof(AdjacencyCost)) {
00221     int* ptr = (int*)&adjTable[0][0];
00222     int size = 16, alloc = 16;
00223     iMesh_getAdjTable( mInstance, &ptr, &alloc, &size, &err );
00224     adjTableErr = (Error)err;
00225   }
00226   else {
00227     int data[16];
00228     int* ptr = data;
00229     int size = 16, alloc = 16;
00230     iMesh_getAdjTable( mInstance, &ptr, &alloc, &size, &err );
00231     adjTableErr = (Error)err;
00232     for (int i = 0; i < 4; ++i)
00233       for (int j = 0; j < 4; ++j)
00234         adjTable[i][j] = (AdjacencyCost)data[4*i+1];
00235   }
00236 }
00237 
00238 inline 
00239 iMesh::iMesh( const char* options )
00240 {
00241   int err, len = options ? strlen(options) : 0;
00242   iMesh_newMesh( options, &mInstance, &err, len );
00243   if (iBase_SUCCESS != err) {
00244     mInstance = 0;
00245     iMeshInstanceOwner = false;
00246   }
00247   else {
00248     iMeshInstanceOwner = true;
00249     cacheAdjTable();
00250   }
00251 }
00252 
00253 inline 
00254 iMesh::iMesh( iMesh_Instance instance )
00255   : iMeshInstanceOwner(false)
00256 {
00257   mInstance = instance;
00258   cacheAdjTable();
00259 }
00260 
00261 inline iMesh::~iMesh()
00262 {
00263   if (iMeshInstanceOwner) {
00264     int err;
00265     iMesh_dtor( mInstance, &err );
00266   }
00267 }
00268 
00269 inline iMesh::Error
00270 iMesh::load( EntitySetHandle set,
00271              const char* file_name,
00272              const char* options )
00273 {
00274   int err, len = options ? strlen(options) : 0;
00275   iMesh_load( mInstance, set, file_name, options, &err, strlen(file_name), len );
00276   return (Error)err;
00277 }
00278 
00279 
00280 inline iMesh::Error
00281 iMesh::save( EntitySetHandle set,
00282              const char* file_name,
00283              const char* options )
00284 {
00285   int err, len = options ? strlen(options) : 0;
00286   iMesh_save( mInstance, set, file_name, options, &err, strlen(file_name), len );
00287   return (Error)err;
00288 }
00289 
00290 
00291 inline int 
00292 iMesh::getGeometricDimension() const
00293 {
00294   int err, result;
00295   iMesh_getGeometricDimension( mInstance, &result, &err );
00296   return iBase_SUCCESS == err ? result : -err;
00297 }
00298 
00299 
00300 inline iMesh::Error
00301 iMesh::setGeometricDimension( int dim )
00302 {
00303   int err;
00304   iMesh_setGeometricDimension( mInstance, dim, &err );
00305   return (Error)err;
00306 }
00307 
00308 inline iMesh::StorageOrder 
00309 iMesh::getDfltStorage() const
00310 {
00311   int err, order;
00312   iMesh_getDfltStorage( mInstance, &order, &err );
00313   return (iBase_SUCCESS == err) ? (StorageOrder)order : iBase_BLOCKED;
00314 }
00315 
00316 inline const iMesh::AdjTableType
00317 iMesh::getAdjTable() 
00318 {
00319   return (iBase_SUCCESS == adjTableErr) ? adjTable : 0;
00320 }
00321   
00322 inline iMesh::Error
00323 iMesh::getNumOfType( EntitySetHandle set, EntityType type, int& count_out  ) const
00324 {
00325   int err;
00326   iMesh_getNumOfType( mInstance, set, type, &count_out, &err );
00327   return (Error)err;
00328 }
00329 
00330 inline iMesh::Error
00331 iMesh::getNumOfTopo( EntitySetHandle set, EntityTopology topo, int& count_out ) const
00332 {
00333   int err;
00334   iMesh_getNumOfTopo( mInstance, set, topo, &count_out, &err );
00335   return (Error)err;
00336 }
00337 
00338 inline bool 
00339 iMesh::optimize()
00340 {
00341   int err, result;
00342   iMesh_optimize( mInstance, &result, &err );
00343   return (iBase_SUCCESS == err) ? !!result : true;
00344 }
00345 
00346 inline iMesh::Error
00347 iMesh::getEntities( EntitySetHandle set,
00348                     EntityType type,
00349                     EntityTopology topo,
00350                     std::vector<EntityHandle>& entities_out ) const
00351 {
00352     // if input vect has no allocated space, allocate some so
00353     // we don't accidentally ask the impl to allocate an array
00354   if (entities_out.capacity() == 0) {
00355     Error err2;
00356     int count;
00357     if (topo == iMesh_ALL_TOPOLOGIES)
00358       err2 = getNumOfType( set, type, count );
00359     else
00360       err2 = getNumOfTopo( set, topo, count );
00361     if (err2 != iBase_SUCCESS)
00362       return err2;
00363     entities_out.resize( count );
00364   }
00365   
00366     // try getting results using whatever space input vector has allocated
00367   int err, size = 0, alloc = entities_out.capacity();
00368   entities_out.resize( entities_out.capacity() );
00369   EntityHandle* ptr = &entities_out[0];
00370   iMesh_getEntities( mInstance, set, type, topo, &ptr, &alloc, &size, &err );
00371   entities_out.resize(size);
00372   
00373     // if input vector was too small, try again with increased size
00374   if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00375     alloc = entities_out.size();
00376     ptr = &entities_out[0];
00377     iMesh_getEntities( mInstance, set, type, topo, &ptr, &alloc, &size, &err );
00378   }
00379   
00380   return (Error)err;
00381 }
00382 
00383 inline iMesh::Error
00384 iMesh::getVtxCoord( EntityHandle vertex, double& x, double& y, double& z ) const
00385 {
00386   int err;
00387   iMesh_getVtxCoord( mInstance, vertex, &x, &y, &z, &err );
00388   return (Error)err;
00389 }
00390 
00391 inline iMesh::Error
00392 iMesh::setVtxCoord( EntityHandle vertex, double x, double y, double z )
00393 {
00394   int err;
00395   iMesh_setVtxCoord( mInstance, vertex, x, y, z, &err );
00396   return (Error)err;
00397 }
00398 
00399 
00400 inline iMesh::Error
00401 iMesh::getVtxArrCoords( const EntityHandle* vertex_handles,
00402                         int vertex_handles_size,
00403                         StorageOrder storage_order,
00404                         double* coords_out ) const
00405 {
00406   int err, alloc = 3*vertex_handles_size, junk, order = storage_order;
00407   iMesh_getVtxArrCoords( mInstance, vertex_handles, vertex_handles_size,
00408                          order, &coords_out, &alloc, &junk, &err );
00409   return (Error)err;
00410 }
00411 
00412 inline iMesh::Error
00413 iMesh::setVtxArrCoords( const EntityHandle* vertex_handles,
00414                         int vertex_handles_size,
00415                         StorageOrder storage_order,
00416                         const double* new_coords )
00417 {
00418   int err, dim = getGeometricDimension();
00419   iMesh_setVtxArrCoords( mInstance, vertex_handles, vertex_handles_size, 
00420                          storage_order, new_coords, dim*vertex_handles_size,
00421                          &err );
00422   return (Error)err;
00423 }
00424 
00425 inline iMesh::Error
00426 iMesh::createVtx( double x, double y, double z, EntityHandle& vertex_out )
00427 {
00428   int err;
00429   iMesh_createVtx( mInstance, x, y, z, &vertex_out, &err );
00430   return (Error)err;
00431 }
00432 
00433 
00434 inline iMesh::Error
00435 iMesh::createVtxArr( int num_verts, 
00436                      StorageOrder storage_order,
00437                      const double* new_coords,
00438                      EntityHandle* new_vertex_handles_out )
00439 {
00440   int err, alloc = num_verts, junk, dim = getGeometricDimension();
00441   iMesh_createVtxArr( mInstance, num_verts, storage_order, new_coords, 
00442                       dim * num_verts, &new_vertex_handles_out,
00443                       &alloc, &junk, &err );
00444   return (Error)err;
00445 }
00446 
00447 inline iMesh::Error
00448 iMesh::createEnt( EntityTopology topology,
00449                   const EntityHandle* entities,
00450                   int entities_size,
00451                   EntityHandle& new_entity_out )
00452 {
00453   int err, status;
00454   iMesh_createEnt( mInstance, topology, entities, entities_size, &new_entity_out, &status, &err );
00455   if (err == iBase_SUCCESS) 
00456     if (status == iBase_ALREADY_EXISTED || status == iBase_CREATION_FAILED)
00457       err = iBase_ENTITY_CREATION_ERROR;
00458   return (Error)err;
00459 }
00460 
00461 inline iMesh::Error
00462 iMesh::createEntArr( EntityTopology new_entity_topology,
00463                      const EntityHandle* lower_order_handles,
00464                      int lower_order_handles_size,
00465                      EntityHandle* new_entity_handles_out )
00466 {
00467   std::vector<int> status(lower_order_handles_size, iBase_CREATION_FAILED);
00468   int err, alloc = lower_order_handles_size, size = 0;
00469   int status_alloc = status.size(), junk, *stat_ptr = &status[0];
00470   
00471   iMesh_createEntArr( mInstance, new_entity_topology, 
00472                       lower_order_handles, lower_order_handles_size, 
00473                       &new_entity_handles_out, &alloc, &size,
00474                       &stat_ptr, &status_alloc, &junk, &err );
00475   
00476   if (iBase_SUCCESS == err) {
00477     for (int i = 0; i < size; ++i)
00478       if (status[i] != iBase_NEW && status[i] != iBase_CREATED_DUPLICATE)
00479         err = iBase_ENTITY_CREATION_ERROR;
00480   }
00481   
00482   if (iBase_SUCCESS != err) {
00483     int err2, w = 0;
00484     for (int r = 0; r < size; ++r) 
00485       if (status[r] == iBase_NEW || status[r] == iBase_CREATED_DUPLICATE) 
00486         new_entity_handles_out[w++] = new_entity_handles_out[r];
00487     iMesh_deleteEntArr( mInstance, new_entity_handles_out, w, &err2 );
00488   }
00489   
00490   return (Error)err;
00491 }
00492 
00493 inline iMesh::Error
00494 iMesh::deleteEnt( EntityHandle handle )
00495 {
00496   int err;
00497   iMesh_deleteEnt( mInstance, handle, &err );
00498   return (Error)err;
00499 }
00500 
00501 inline iMesh::Error
00502 iMesh::deleteEntArr( const EntityHandle* entity_handles, int num_handles )
00503 {
00504   int err;
00505   iMesh_deleteEntArr( mInstance, entity_handles, num_handles, &err );
00506   return (Error)err;
00507 }
00508 
00509 inline iMesh::Error
00510 iMesh::getAdjEntities( EntitySetHandle set,
00511                        EntityType type_requestor,
00512                        EntityTopology topo_requestor,
00513                        EntityType type_requested,
00514                        std::vector<EntityHandle>& adj_entity_handles,
00515                        std::vector<int>& offset ) const
00516 {
00517   std::vector<EntityHandle> entities;
00518   Error err = getEntities( set, type_requestor, topo_requestor, entities );
00519   if (iBase_SUCCESS != err)
00520     return err;
00521   
00522   offset.resize( entities.size() + 1 );
00523   return getEntArrAdj( &entities[0], entities.size(), type_requested,
00524                        adj_entity_handles, &offset[0] );
00525 }
00526     
00527 inline iMesh::Error 
00528 iMesh::initEntIter( EntitySetHandle set,
00529                     EntityType requested_type,
00530                     EntityTopology requested_topo,
00531                        int resilient,
00532                     iMesh::EntIter& iter )
00533 {
00534   int err;
00535   iter.mInstance = mInstance;
00536   iMesh_initEntIter( mInstance, set, requested_type, requested_topo, resilient,
00537                      &iter.mHandle, &err );
00538   return (Error)err;
00539 }
00540 
00541 inline iMesh::Error 
00542 iMesh::initEntArrIter( EntitySetHandle set,
00543                        EntityType requested_type,
00544                        EntityTopology requested_topo,
00545                        int requested_array_size,
00546                        int resilient,
00547                        iMesh::EntArrIter& iter )
00548 {
00549   int err;
00550   iter.mInstance = mInstance;
00551   iter.mSize = requested_array_size;
00552   iMesh_initEntArrIter( mInstance, set, requested_type, requested_topo,
00553                         requested_array_size, resilient, &iter.mHandle, &err );
00554   return (Error)err;
00555 }
00556 
00557 inline 
00558 iMesh::EntArrIter::~EntArrIter()
00559 {
00560   int err;
00561   if (mHandle != 0) {
00562     iMesh_endEntArrIter( mInstance, mHandle, &err );
00563     mHandle = 0;
00564   }
00565 }
00566 
00567 inline 
00568 iMesh::EntIter::~EntIter()
00569 {
00570   int err;
00571   if (mHandle != 0) {
00572     iMesh_endEntIter( mInstance, mHandle, &err );
00573     mHandle = 0;
00574   }
00575 }
00576 
00577 inline iMesh::Error
00578 iMesh::EntArrIter::getNext( EntityHandle* entity_handles,
00579                             int& size_out,
00580                             bool& has_more_data_out )
00581 {
00582   int err, alloc = mSize, has_data;
00583   iMesh_getNextEntArrIter( mInstance, mHandle, &entity_handles, &alloc,
00584                            &size_out, &has_data, &err );
00585   has_more_data_out = (has_data != 0);
00586   return (Error)err;
00587 }
00588 
00589 inline iMesh::Error
00590 iMesh::EntIter::getNext( EntityHandle& handle_out, bool& has_more_data_out )
00591 {
00592   int err, has_data;
00593   iMesh_getNextEntIter( mInstance, mHandle, &handle_out, &has_data, &err );
00594   has_more_data_out = (has_data != 0);
00595   return (Error)err;
00596 }
00597 
00598 inline iMesh::Error
00599 iMesh::EntArrIter::reset()
00600 {
00601   int err;
00602   iMesh_resetEntArrIter( mInstance, mHandle, &err );
00603   return (Error)err;
00604 }
00605 
00606 inline iMesh::Error
00607 iMesh::EntIter::reset()
00608 {
00609   int err;
00610   iMesh_resetEntIter( mInstance, mHandle, &err );
00611   return (Error)err;
00612 }
00613 
00614 inline iMesh::Error
00615 iMesh::getEntTopo( EntityHandle handle, EntityTopology& topo_out ) const
00616 {
00617   int err, result;
00618   iMesh_getEntTopo( mInstance, handle, &result, &err );
00619   topo_out = (EntityTopology)result;
00620   return (Error)err;
00621 }
00622 
00623 inline iMesh::Error
00624 iMesh::getEntArrTopo( const EntityHandle* entity_handles,
00625                       int entity_handles_size,
00626                       EntityTopology* topos_out ) const 
00627 {
00628   int err, alloc = entity_handles_size, junk, *ptr;
00629   std::vector<int> storage;
00630   if (sizeof(EntityTopology) == sizeof(int))
00631     ptr = reinterpret_cast<int*>(topos_out);
00632   else {
00633     storage.resize( entity_handles_size );
00634     ptr = &storage[0];
00635   }
00636   
00637   iMesh_getEntArrTopo( mInstance, entity_handles, entity_handles_size,
00638                        &ptr, &alloc, &junk, &err );
00639   
00640   if (sizeof(EntityTopology) != sizeof(int))
00641     for (int i = 0; i < entity_handles_size; ++i)
00642       topos_out[i] = (EntityTopology)storage[i];
00643       
00644   return (Error)err;
00645 }
00646  
00647 inline iMesh::Error
00648 iMesh::getEntType( EntityHandle handle, EntityType& type_out ) const
00649 {
00650   int err, result;
00651   iMesh_getEntType( mInstance, handle, &result, &err );
00652   type_out = (EntityType)result;
00653   return (Error)err;
00654 }
00655 
00656 inline iMesh::Error
00657 iMesh::getEntArrType( const EntityHandle* entity_handles,
00658                       int entity_handles_size,
00659                       EntityType* types_out ) const
00660 {
00661   int err, alloc = entity_handles_size, junk, *ptr;
00662   std::vector<int> storage;
00663   if (sizeof(EntityType) == sizeof(int))
00664     ptr = reinterpret_cast<int*>(types_out);
00665   else {
00666     storage.resize( entity_handles_size );
00667     ptr = &storage[0];
00668   }
00669   
00670   iMesh_getEntArrType( mInstance, entity_handles, entity_handles_size,
00671                        &ptr, &alloc, &junk, &err );
00672   
00673   if (sizeof(EntityType) != sizeof(int))
00674     for (int i = 0; i < entity_handles_size; ++i)
00675       types_out[i] = (EntityType)storage[i];
00676       
00677   return (Error)err;
00678 }
00679 
00680 inline iMesh::Error
00681 iMesh::getEntAdj( EntityHandle handle, 
00682                   EntityType type_requested,
00683                   std::vector<EntityHandle>& adj_entities_out ) const
00684 {
00685   if (adj_entities_out.capacity() == 0) 
00686     adj_entities_out.resize(12);
00687   else
00688     adj_entities_out.resize( adj_entities_out.capacity() );
00689   
00690   int err, alloc = adj_entities_out.size(), size = 0;
00691   EntityHandle* ptr = &adj_entities_out[0];
00692   iMesh_getEntAdj( mInstance, handle, type_requested, 
00693                    &ptr, &alloc, &size, &err );
00694   adj_entities_out.resize(size);
00695   
00696   if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00697     alloc = adj_entities_out.size();
00698     ptr = &adj_entities_out[0];
00699     iMesh_getEntAdj( mInstance, handle, type_requested, 
00700                      &ptr, &alloc, &size, &err );
00701   }
00702   
00703   return (Error)err;
00704 }
00705 
00706 inline iMesh::Error
00707 iMesh::getEntArrAdj( const EntityHandle* entity_handles,
00708                            int entity_handles_size,
00709                            EntityType type_requested,
00710                            std::vector<EntityHandle>& adj_entities_out,
00711                            int* offsets_out ) const
00712 {
00713   if (adj_entities_out.capacity() == 0) 
00714     adj_entities_out.resize(12*entity_handles_size);
00715   else
00716     adj_entities_out.resize( adj_entities_out.capacity() );
00717   
00718   int err, alloc = adj_entities_out.size(), size = 0;
00719   int off_alloc = entity_handles_size+1, junk;
00720   EntityHandle* ptr = &adj_entities_out[0];
00721   iMesh_getEntArrAdj( mInstance, entity_handles, entity_handles_size, 
00722                       type_requested,
00723                       &ptr, &alloc, &size,
00724                       &offsets_out, &off_alloc, &junk,
00725                       &err );
00726   adj_entities_out.resize(size);
00727   
00728   if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00729     alloc = adj_entities_out.size();
00730     ptr = &adj_entities_out[0];
00731     iMesh_getEntArrAdj( mInstance, entity_handles, entity_handles_size, 
00732                         type_requested,
00733                         &ptr, &alloc, &size,
00734                         &offsets_out, &off_alloc, &junk,
00735                         &err );
00736   }
00737   
00738   return (Error)err;
00739 }
00740 
00741                    
00742 inline iMesh::Error
00743 iMesh::getEnt2ndAdj( EntityHandle handle, 
00744                      EntityType bridge_entity_type,
00745                      EntityType type_requested,
00746                      std::vector<EntityHandle> adj_entities_out ) const
00747 {
00748   if (adj_entities_out.capacity() == 0) 
00749     adj_entities_out.resize(12);
00750   else
00751     adj_entities_out.resize( adj_entities_out.capacity() );
00752   
00753   int err, alloc = adj_entities_out.size(), size = 0;
00754   EntityHandle* ptr = &adj_entities_out[0];
00755   iMesh_getEnt2ndAdj( mInstance, handle, bridge_entity_type, type_requested, 
00756                       &ptr, &alloc, &size, &err );
00757   adj_entities_out.resize(size);
00758   
00759   if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00760     alloc = adj_entities_out.size();
00761     ptr = &adj_entities_out[0];
00762     iMesh_getEnt2ndAdj( mInstance, handle, bridge_entity_type, type_requested, 
00763                        &ptr, &alloc, &size, &err );
00764   }
00765   
00766   return (Error)err;
00767 }
00768 
00769 inline iMesh::Error
00770 iMesh::getEntArr2ndAdj( const EntityHandle* entity_handles,
00771                         int entity_handles_size,
00772                         EntityType order_key,
00773                         EntityType type_requested,
00774                         std::vector<EntityHandle>& adj_entities_out,
00775                         int* offsets_out ) const
00776 {
00777   if (adj_entities_out.capacity() == 0) 
00778     adj_entities_out.resize(12*entity_handles_size);
00779   else
00780     adj_entities_out.resize( adj_entities_out.capacity() );
00781   
00782   int err, alloc = adj_entities_out.size(), size = 0;
00783   int off_alloc = entity_handles_size+1, junk;
00784   EntityHandle* ptr = &adj_entities_out[0];
00785   iMesh_getEntArr2ndAdj( mInstance, entity_handles, entity_handles_size, 
00786                          order_key, type_requested,
00787                          &ptr, &alloc, &size,
00788                          &offsets_out, &off_alloc, &junk,
00789                          &err );
00790   adj_entities_out.resize(size);
00791   
00792   if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00793     alloc = adj_entities_out.size();
00794     ptr = &adj_entities_out[0];
00795     iMesh_getEntArr2ndAdj( mInstance, entity_handles, entity_handles_size, 
00796                            order_key, type_requested,
00797                            &ptr, &alloc, &size,
00798                            &offsets_out, &off_alloc, &junk,
00799                            &err );
00800   }
00801   
00802   return (Error)err;
00803 }
00804 
00805 
00806 inline iMesh::Error
00807 iMesh::getAdjEntIndices( EntitySetHandle set,
00808                          EntityType requestor_type,
00809                          EntityTopology requestor_topo,
00810                          EntityType type_requested,
00811                          std::vector<EntityHandle>& entities_out,
00812                          std::vector<EntityHandle>& adj_entities_out,
00813                          std::vector<int>& adj_indices_out,
00814                          std::vector<int>& offsets_out ) const
00815 {
00816     // if input vects have no allocated space, allocate some so
00817     // we don't accidentally ask the impl to allocate an array
00818   if (entities_out.capacity() == 0) {
00819     Error err2;
00820     int count;
00821     if (requestor_topo == iMesh_ALL_TOPOLOGIES)
00822       err2 = getNumOfType( set, requestor_type, count );
00823     else
00824       err2 = getNumOfTopo( set, requestor_topo, count );
00825     if (err2 != iBase_SUCCESS)
00826       return err2;
00827     entities_out.resize( count );
00828   }
00829   else
00830     entities_out.resize( entities_out.capacity() );
00831     
00832   if (adj_entities_out.capacity() == 0)
00833     adj_entities_out.resize( 12*entities_out.size() );
00834   else
00835     adj_entities_out.resize( adj_entities_out.capacity() );
00836     
00837   if (adj_indices_out.capacity() == 0)
00838     adj_indices_out.resize( 12*entities_out.size() );
00839   else
00840     adj_indices_out.resize( adj_indices_out.capacity() );
00841     
00842   if (offsets_out.capacity() == 0)
00843     offsets_out.resize( entities_out.size() + 1 );
00844   else
00845     offsets_out.resize( offsets_out.capacity() );
00846 
00847   int err;
00848   int     entities_size = 0,     entities_alloc =     entities_out.size();
00849   int adj_entities_size = 0, adj_entities_alloc = adj_entities_out.size();
00850   int  adj_indices_size = 0,  adj_indices_alloc =  adj_indices_out.size();
00851   int      offsets_size = 0,      offsets_alloc =      offsets_out.size();
00852   EntityHandle*     entities_ptr = &    entities_out[0];
00853   EntityHandle* adj_entities_ptr = &adj_entities_out[0];
00854   int         *  adj_indices_ptr = & adj_indices_out[0];
00855   int         *      offsets_ptr = &     offsets_out[0];
00856   
00857   iMesh_getAdjEntIndices( mInstance, 
00858                           set, requestor_type, requestor_topo,
00859                           type_requested,
00860                           &    entities_ptr, &    entities_alloc, &    entities_size,
00861                           &adj_entities_ptr, &adj_entities_alloc, &adj_entities_size,
00862                           & adj_indices_ptr, & adj_indices_alloc, & adj_indices_size,
00863                           &     offsets_ptr, &     offsets_alloc, &     offsets_size,
00864                           &err );
00865   
00866       entities_out.resize(     entities_size );
00867   adj_entities_out.resize( adj_entities_size );
00868    adj_indices_out.resize(  adj_indices_size );
00869        offsets_out.resize(      offsets_size );
00870   
00871   if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
00872         entities_alloc =     entities_out.size();
00873     adj_entities_alloc = adj_entities_out.size();
00874      adj_indices_alloc =  adj_indices_out.size();
00875          offsets_alloc =      offsets_out.size();
00876         entities_ptr = &    entities_out[0];
00877     adj_entities_ptr = &adj_entities_out[0];
00878      adj_indices_ptr = & adj_indices_out[0];
00879          offsets_ptr = &     offsets_out[0];
00880 
00881     iMesh_getAdjEntIndices( mInstance, 
00882                             set, requestor_type, requestor_topo,
00883                             type_requested,
00884                             &    entities_ptr, &    entities_alloc, &    entities_size,
00885                             &adj_entities_ptr, &adj_entities_alloc, &adj_entities_size,
00886                             & adj_indices_ptr, & adj_indices_alloc, & adj_indices_size,
00887                             &     offsets_ptr, &     offsets_alloc, &     offsets_size,
00888                             &err );
00889   }
00890   
00891   return (Error)err;
00892 }
00893 
00894 #endif
00895 
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines