MOAB: Mesh Oriented datABase  (version 5.3.0)
iMesh.h
Go to the documentation of this file.
00001 #ifndef _ITAPS_iMesh
00002 #define _ITAPS_iMesh
00003 
00004 #include "iBase.h"
00005 #include "iMesh_protos.h"
00006 
00007 /***************************************************************************/ /**
00008                                                                                * \ingroup
00009                                                                                *VersionNumbers
00010                                                                                * \brief Compile time
00011                                                                                *version number
00012                                                                                *digits
00013                                                                                *
00014                                                                                * iMesh maintains a
00015                                                                                *major, minor and
00016                                                                                *patch digit in its
00017                                                                                *version number.
00018                                                                                * Technically
00019                                                                                *speaking, there is
00020                                                                                *not much practical
00021                                                                                *value in patch digit
00022                                                                                * for an interface
00023                                                                                *specification. A
00024                                                                                *patch release is
00025                                                                                *typically only used
00026                                                                                * for bug fix
00027                                                                                *releases. Although
00028                                                                                *it is rare,
00029                                                                                *sometimes a bug fix
00030                                                                                * necessitates an API
00031                                                                                *change. So, we
00032                                                                                *define a patch digit
00033                                                                                *for iMesh.
00034                                                                                ******************************************************************************/
00035 #define IMESH_VERSION_MAJOR ITAPS_VERSION_MAJOR
00036 #define IMESH_VERSION_MINOR ITAPS_VERSION_MINOR
00037 #define IMESH_VERSION_PATCH ITAPS_VERSION_PATCH
00038 
00039 /***************************************************************************/ /**
00040                                                                                * \ingroup
00041                                                                                *VersionNumbers
00042                                                                                * \brief Maintain
00043                                                                                *backward
00044                                                                                *compatibility with
00045                                                                                *old version symbol
00046                                                                                *names
00047                                                                                ******************************************************************************/
00048 #define IMESH_MAJOR_VERSION IMESH_VERSION_MAJOR
00049 #define IMESH_MINOR_VERSION IMESH_VERSION_MINOR
00050 #define IMESH_PATCH_VERSION IMESH_VERSION_PATCH
00051 
00052 /***************************************************************************/ /**
00053                                                                                * \ingroup
00054                                                                                *VersionNumbers
00055                                                                                * \brief Version
00056                                                                                *Comparison
00057                                                                                *
00058                                                                                * Evaluates to true
00059                                                                                *at CPP time if the
00060                                                                                *version of iMesh
00061                                                                                *currently being
00062                                                                                * compiled is greater
00063                                                                                *than or equal to the
00064                                                                                *version specified.
00065                                                                                ******************************************************************************/
00066 #define IMESH_VERSION_GE( Maj, Min, Pat ) ITAPS_VERSION_GE( Maj, Min, Pat )
00067 
00068 /***************************************************************************/ /**
00069                                                                                * \ingroup
00070                                                                                *VersionNumbers
00071                                                                                * \brief Compose
00072                                                                                *string represention
00073                                                                                *of the iMesh version
00074                                                                                *number
00075                                                                                ******************************************************************************/
00076 #define IMESH_VERSION_STRING ITAPS_VERSION_STRING_( iMesh )
00077 
00078 /***************************************************************************/ /**
00079                                                                                * \ingroup
00080                                                                                *VersionNumbers
00081                                                                                * \brief Compose a
00082                                                                                *symbol name derived
00083                                                                                *from the current
00084                                                                                *iMesh version
00085                                                                                *number.
00086                                                                                ******************************************************************************/
00087 #define IMESH_VERSION_TAG ITAPS_VERSION_TAG_( iMesh )
00088 
00089 /***************************************************************************/ /**
00090                                                                                * \ingroup
00091                                                                                *VersionNumbers
00092                                                                                * \brief Define
00093                                                                                *iMesh_newMesh symbol
00094                                                                                *such that it depends
00095                                                                                *on version number.
00096                                                                                *
00097                                                                                * Note: We ran into
00098                                                                                *problems with this
00099                                                                                *as it influences or
00100                                                                                *is influenced by
00101                                                                                * fortran name
00102                                                                                *mangling and so
00103                                                                                *breaks fortran
00104                                                                                *compilation. So,
00105                                                                                *this is currently
00106                                                                                *disabled.
00107                                                                                ******************************************************************************/
00108 #define IMESH_NEW_MESH_NAME__( A, B, C ) A##_##B##_##C
00109 #define IMESH_NEW_MESH_NAME_( A, B, C ) IMESH_NEW_MESH_NAME__( A, B, C )
00110 #define IMESH_NEW_MESH_NAME( A ) IMESH_NEW_MESH_NAME_( A, IMESH_VERSION_MAJOR, IMESH_VERSION_MINOR )
00111 /*
00112 #undef  iMesh_newMesh
00113 #define iMesh_newMesh IMESH_NEW_MESH_NAME(iMesh_newMesh)
00114 */
00115 
00116 #ifdef __cplusplus
00117 extern "C" {
00118 #endif
00119 
00120 /***************************************************************************/ /**
00121                                                                                * \ingroup Datatypes
00122                                                                                * \brief iMesh
00123                                                                                *instance
00124                                                                                ******************************************************************************/
00125 typedef struct iMesh_Instance_Private* iMesh_Instance;
00126 
00127 /***************************************************************************/ /**
00128                                                                                * \ingroup Datatypes
00129                                                                                * \brief Entity
00130                                                                                *Topology
00131                                                                                ******************************************************************************/
00132 enum iMesh_EntityTopology
00133 {
00134     iMesh_EntityTopology_MIN = 0,
00135     /**< MIN symbol used to facilitate iteration over topologies */
00136     iMesh_POINT = iMesh_EntityTopology_MIN,
00137     /**< a 0D entity (e.g. a vertex) */
00138     iMesh_LINE_SEGMENT,
00139     /**< a 1D entity (e.g. an edge) */
00140     iMesh_POLYGON,
00141     /**< a general 2D entity */
00142     iMesh_TRIANGLE,
00143     /**< a specific 2D entity bounded by 3 edge entities */
00144     iMesh_QUADRILATERAL,
00145     /**< a specific 2D entity bounded by 4 edge entities */
00146     iMesh_POLYHEDRON,
00147     /**< a general 3D entity */
00148     iMesh_TETRAHEDRON,
00149     /**< a specific 3D entity bounded by 4 triangle entities */
00150     iMesh_HEXAHEDRON,
00151     /**< a specific 3D entity bounded by 6 quadrilateral entities */
00152     iMesh_PRISM,
00153     /**< a specific 3D entity bounded by a combination of 3 quadrilateral
00154         entities and 2 triangle entities */
00155     iMesh_PYRAMID,
00156     /**< a specific 3D entity bounded by a combination of 1 quadrilateral
00157          entity and 4 triangle entities */
00158     iMesh_SEPTAHEDRON,
00159     /**< a hexahedral entity with one collapsed edge */
00160     iMesh_ALL_TOPOLOGIES,
00161     /**< used only in queries to request information about all topologies */
00162     iMesh_EntityTopology_MAX = iMesh_ALL_TOPOLOGIES
00163     /**< MAX symbol used to facilitate iteration over topologies */
00164 };
00165 
00166 /***************************************************************************/ /**
00167                                                                                * \ingroup
00168                                                                                *ErrorHandling \brief
00169                                                                                *Get the error type
00170                                                                                *returned from the
00171                                                                                *last iMesh function
00172                                                                                ******************************************************************************/
00173 void iMesh_getErrorType( iMesh_Instance instance,
00174                          /**< [in] iMesh instance handle */
00175                          int* error_type
00176                          /**< [out] Error type returned from last iMesh function
00177                               (see iBase_ErrorType) */
00178 
00179 );
00180 
00181 /***************************************************************************/ /**
00182                                                                                * \ingroup
00183                                                                                *ErrorHandling \brief
00184                                                                                *Get a description of
00185                                                                                *the error returned
00186                                                                                *from the last iMesh
00187                                                                                *function
00188                                                                                ******************************************************************************/
00189 void iMesh_getDescription( iMesh_Instance instance,
00190                            /**< [in] iMesh instance handle */
00191                            char* descr,
00192                            /**< [in,out] Pointer to a character string to be filled with a
00193                               description of the error from the last iMesh function */
00194                            int descr_len
00195                            /**< [in] Length of the character string pointed to by descr
00196                                 (\ref strlen) */
00197 );
00198 
00199 /***************************************************************************/ /**
00200                                                                                * \ingroup
00201                                                                                *Initialization
00202                                                                                * \brief  Construct a
00203                                                                                *new iMesh instance
00204                                                                                *
00205                                                                                ******************************************************************************/
00206 
00207 void iMesh_newMesh( const char* options,
00208                     /**< [in] Pointer to implementation-specific options string
00209                          (\ref options) */
00210                     iMesh_Instance* instance,
00211                     /**< [in] iMesh instance handle */
00212                     int* err,
00213                     /**< [out] Returned Error status (see iBase_ErrorType) */
00214                     int options_len
00215                     /**< [in] Length of the character string pointed to by options
00216                          (\ref strlen) */
00217 );
00218 
00219 /***************************************************************************/ /**
00220                                                                                * \ingroup
00221                                                                                *Initialization
00222                                                                                * \brief  Destroy an
00223                                                                                *iMesh instance
00224                                                                                *
00225                                                                                ******************************************************************************/
00226 
00227 void iMesh_dtor( iMesh_Instance instance,
00228                  /**< [in] iMesh instance handle */
00229                  int* err
00230                  /**< [out] Returned Error status (see iBase_ErrorType) */
00231 );
00232 
00233 /***************************************************************************/ /**
00234                                                                                * \ingroup
00235                                                                                *Initialization
00236                                                                                * \brief  Load a mesh
00237                                                                                *from a file
00238                                                                                *
00239                                                                                * Load a mesh from a
00240                                                                                *file.  If entity set
00241                                                                                *is specified, loaded
00242                                                                                *mesh is added to
00243                                                                                *that set; specify
00244                                                                                *root set if that is
00245                                                                                *not desired.
00246                                                                                ******************************************************************************/
00247 
00248 void iMesh_load( iMesh_Instance instance,
00249                  /**< [in] iMesh instance handle */
00250                  const iBase_EntitySetHandle entity_set_handle,
00251                  /**< [in] Set to which loaded mesh will be added, otherwise root */
00252                  const char* name,
00253                  /**< [in] File name from which mesh is to be loaded */
00254                  const char* options,
00255                  /**< [in] Pointer to implementation-specific options string
00256                       (\ref options) */
00257                  int* err,
00258                  /**< [out] Returned Error status (see iBase_ErrorType) */
00259                  int name_len,
00260                  /**< [in] Length of the file name character string
00261                       (\ref strlen) */
00262                  int options_len
00263                  /**< [in] Length of the options character string
00264                       (\ref strlen) */
00265 );
00266 
00267 /***************************************************************************/ /**
00268                                                                                * \ingroup
00269                                                                                *Initialization
00270                                                                                * \brief  Save a mesh
00271                                                                                *to a file
00272                                                                                *
00273                                                                                * Save a mesh to a
00274                                                                                *file.  If entity set
00275                                                                                *is specified, save
00276                                                                                *only the mesh
00277                                                                                *contained in that
00278                                                                                *set.
00279                                                                                ******************************************************************************/
00280 
00281 void iMesh_save( iMesh_Instance instance,
00282                  /**< [in] iMesh instance handle */
00283                  const iBase_EntitySetHandle entity_set_handle,
00284                  /**< [in] Entity set being saved */
00285                  const char* name,
00286                  /**< [in] File name to which mesh is to be saved */
00287                  const char* options,
00288                  /**< [in] Pointer to implementation-specific options string
00289                       (\ref options) */
00290                  int* err,
00291                  /**< [out] Returned Error status (see iBase_ErrorType) */
00292                  const int name_len,
00293                  /**< [in] Length of the file name character string
00294                       (\ref strlen) */
00295                  int options_len
00296                  /**< [in] Length of the options character string
00297                       (\ref strlen) */
00298 );
00299 
00300 /***************************************************************************/ /**
00301                                                                                * \ingroup
00302                                                                                *Initialization
00303                                                                                * \brief  Get handle
00304                                                                                *of the root set for
00305                                                                                *this instance
00306                                                                                *
00307                                                                                * Get handle of the
00308                                                                                *root set for this
00309                                                                                *instance.  All mesh
00310                                                                                *entities in this
00311                                                                                *instance can be
00312                                                                                *accessed from this
00313                                                                                *set.
00314                                                                                ******************************************************************************/
00315 
00316 void iMesh_getRootSet( iMesh_Instance instance,
00317                        /**< [in] iMesh instance handle */
00318                        iBase_EntitySetHandle* root_set,
00319                        /**< [out] Pointer to set handle returned from function */
00320                        int* err
00321                        /**< [out] Returned Error status (see iBase_ErrorType) */
00322 );
00323 
00324 /***************************************************************************/ /**
00325                                                                                * \ingroup
00326                                                                                *Initialization
00327                                                                                * \brief  Get the
00328                                                                                *geometric dimension
00329                                                                                *of mesh represented
00330                                                                                *in this instance
00331                                                                                *
00332                                                                                ******************************************************************************/
00333 
00334 void iMesh_getGeometricDimension( iMesh_Instance instance,
00335                                   /**< [in] iMesh instance handle */
00336                                   int* geom_dim,
00337                                   /**< [out] Pointer to dimension returned from this function */
00338                                   int* err
00339                                   /**< [out] Returned Error status (see iBase_ErrorType) */
00340 );
00341 
00342 /***************************************************************************/ /**
00343                                                                                * \ingroup
00344                                                                                *Initialization
00345                                                                                * \brief  Set
00346                                                                                *geometric dimension
00347                                                                                *of vertex
00348                                                                                *coordinates
00349                                                                                *
00350                                                                                * Set the geometric
00351                                                                                *dimension of the
00352                                                                                *mesh.  Note:  An
00353                                                                                *application should
00354                                                                                *not expect this
00355                                                                                *function to succeed
00356                                                                                *unless the mesh
00357                                                                                *instance is empty.
00358                                                                                *An empty mesh
00359                                                                                *instance is any mesh
00360                                                                                *instance in which
00361                                                                                *there are no vertex
00362                                                                                *entities.
00363                                                                                ******************************************************************************/
00364 
00365 void iMesh_setGeometricDimension( iMesh_Instance instance,
00366                                   /**< [in] iMesh instance handle */
00367                                   int geom_dim,
00368                                   /**< [in] Requested geometric dimension. */
00369                                   int* err
00370                                   /**< [out] Returned Error status (see iBase_ErrorType) */
00371 );
00372 
00373 /***************************************************************************/ /**
00374                                                                                * \ingroup
00375                                                                                *Initialization
00376                                                                                * \brief  Get the
00377                                                                                *default storage
00378                                                                                *order used by this
00379                                                                                *implementation
00380                                                                                *
00381                                                                                * Get the default
00382                                                                                *storage order used
00383                                                                                *by this
00384                                                                                *implementation.
00385                                                                                *Value returned is a
00386                                                                                *member of the
00387                                                                                *iBase_StorageOrder
00388                                                                                *enumeration.
00389                                                                                ******************************************************************************/
00390 
00391 void iMesh_getDfltStorage( iMesh_Instance instance,
00392                            /**< [in] iMesh instance handle */
00393                            int* order,
00394                            /**< [out] Pointer to storage order returned from function
00395                                 (\sa iBase_StorageOrder) */
00396                            int* err
00397                            /**< [out] Returned Error status (see iBase_ErrorType) */
00398 );
00399 
00400 /***************************************************************************/ /**
00401                                                                                * \ingroup
00402                                                                                *Adjacencies \brief
00403                                                                                *Get the adjacency
00404                                                                                *table for this
00405                                                                                *implementation
00406                                                                                *
00407                                                                                * Get the adjacency
00408                                                                                *table for this
00409                                                                                *implementation. This
00410                                                                                *table is a 4x4 array
00411                                                                                *whose entries
00412                                                                                *characterize how the
00413                                                                                *implementation
00414                                                                                * behaves when
00415                                                                                *adjacent and
00416                                                                                *intermediate
00417                                                                                *entities are
00418                                                                                *queried. Entry [i,j]
00419                                                                                *(i=row, j=col,
00420                                                                                *0-based indexing)
00421                                                                                *will have one of the
00422                                                                                *values in the
00423                                                                                *iBase_AdjacencyCost
00424                                                                                *enumeration.
00425                                                                                *Off-diagonal entres,
00426                                                                                *i!=j, represents the
00427                                                                                *relative cost of
00428                                                                                *retrieving entities
00429                                                                                *of dimension i
00430                                                                                *adjacent to entities
00431                                                                                *of dimension j.
00432                                                                                * Diagonal entries,
00433                                                                                *i==j, indicate
00434                                                                                *whether or not
00435                                                                                *handles to ALL
00436                                                                                * entities of that
00437                                                                                *dimension are
00438                                                                                *obtainable from
00439                                                                                *calls that return
00440                                                                                * entity handles.
00441                                                                                *This is always true
00442                                                                                *by definition for
00443                                                                                *i==j==0 as well as
00444                                                                                *for i==j==2 in a 2D
00445                                                                                *mesh and i==j==3 in
00446                                                                                *a 3D mesh. However,
00447                                                                                *diagonal entries
00448                                                                                *[1,1] for a 2D mesh
00449                                                                                *and both [1,1] and
00450                                                                                *[2,2] for a 3D mesh
00451                                                                                *indicate whether or
00452                                                                                *not handles to ALL
00453                                                                                * intermediate
00454                                                                                *dimensioned entities
00455                                                                                *(ALL edges in a 2D
00456                                                                                *mesh or ALL edges
00457                                                                                *and ALL faces in a
00458                                                                                *3D mesh) are
00459                                                                                *obtainable from
00460                                                                                *calls that return
00461                                                                                *entity handles. A
00462                                                                                *value of
00463                                                                                *iBase_AVAILABLE for
00464                                                                                *a diagonal entry
00465                                                                                *indicates that
00466                                                                                *handles are
00467                                                                                *obtainable for ALL
00468                                                                                * entities of that
00469                                                                                *dimension while a
00470                                                                                *value of
00471                                                                                *iBase_UNAVAILABLE
00472                                                                                * indicates that
00473                                                                                *handles are not
00474                                                                                *obtainable for ALL
00475                                                                                *entities of that
00476                                                                                * dimension.
00477                                                                                ******************************************************************************/
00478 
00479 void iMesh_getAdjTable( iMesh_Instance instance,
00480                         /**< [in] iMesh instance handle */
00481                         int** adjacency_table,
00482                         /**< [out] Pointer to array representing adjacency table
00483                              \ref trio) */
00484                         int* adjacency_table_allocated,
00485                         /**< [in,out] Pointer to allocated size of adjacency_table */
00486                         int* adjacency_table_size,
00487                         /**< [out] Pointer to occupied size of adjacency_table */
00488                         int* err
00489                         /**< [out] Returned Error status (see iBase_ErrorType) */
00490 );
00491 
00492 /***************************************************************************/ /**
00493                                                                                * \ingroup
00494                                                                                *Adjacencies \brief
00495                                                                                *Set the adjacency
00496                                                                                *table as requested
00497                                                                                *by the application
00498                                                                                *
00499                                                                                * Set the adjacency
00500                                                                                *table as requested
00501                                                                                *by the application.
00502                                                                                * See
00503                                                                                *iMesh_getAdjTable
00504                                                                                *for a description of
00505                                                                                *the meaning of the
00506                                                                                *entries in this
00507                                                                                *table. This call to
00508                                                                                *set the adjacency
00509                                                                                *table allows an
00510                                                                                *application to
00511                                                                                *request how it would
00512                                                                                *like an
00513                                                                                *implementation to
00514                                                                                *behave when adjacent
00515                                                                                * and/or intermediate
00516                                                                                *entities are
00517                                                                                *queried. If the
00518                                                                                *implementation is
00519                                                                                *not able to
00520                                                                                *accommodate the
00521                                                                                *requested query
00522                                                                                *behavior associated
00523                                                                                *with ANY entry in
00524                                                                                *the table, the call
00525                                                                                *will fail and return
00526                                                                                *an error of
00527                                                                                * iBase_NOT_SUPPORTED.
00528                                                                                *Otherwise, the
00529                                                                                *implementation is
00530                                                                                *able to accommodate
00531                                                                                * the requested query
00532                                                                                *behavior associated
00533                                                                                *with ALL table
00534                                                                                *entries and the call
00535                                                                                *will succeed. In
00536                                                                                *either case,
00537                                                                                *however, the
00538                                                                                *implementation will
00539                                                                                * over-write the
00540                                                                                *entries in the
00541                                                                                *adjacency_table
00542                                                                                *argument with the
00543                                                                                *same values that
00544                                                                                *would be obtained in
00545                                                                                *a succeeding call to
00546                                                                                *iMesh_getAdjTable.
00547                                                                                ******************************************************************************/
00548 
00549 void iMesh_setAdjTable( iMesh_Instance instance,
00550                         /**< [in] iMesh instance handle */
00551                         int* adjacency_table,
00552                         /**< [in,out] Array representing adjacency table requested by
00553                              application */
00554                         int adjacency_table_size,
00555                         /**< [in] Size of adj table array */
00556                         int* err
00557                         /**< [out] Returned Error status (see iBase_ErrorType) */
00558 );
00559 
00560 /***************************************************************************/ /**
00561                                                                                * \ingroup EntitySets
00562                                                                                * \brief  Get the
00563                                                                                *number of entities
00564                                                                                *of specified type in
00565                                                                                *the instance or set
00566                                                                                *
00567                                                                                * Get the number of
00568                                                                                *entities with the
00569                                                                                *specified type in
00570                                                                                *the instance or set.
00571                                                                                *If entity set handle
00572                                                                                *is root set, return
00573                                                                                *information for
00574                                                                                *instance, otherwise
00575                                                                                *for set.  Value of
00576                                                                                *entity type must be
00577                                                                                *from the
00578                                                                                * iBase_EntityType
00579                                                                                *enumeration.  If
00580                                                                                *iBase_ALL_TYPES is
00581                                                                                *specified, total
00582                                                                                *number of entities
00583                                                                                *(excluding entity
00584                                                                                *sets) is returned.
00585                                                                                ******************************************************************************/
00586 
00587 void iMesh_getNumOfType( iMesh_Instance instance,
00588                          /**< [in] iMesh instance handle */
00589                          const iBase_EntitySetHandle entity_set_handle,
00590                          /**< [in] Entity set being queried */
00591                          const int entity_type,
00592                          /**< [in] Type of entity requested */
00593                          int* num_type,
00594                          /**< [out] Pointer to number of entities, returned from function */
00595                          int* err
00596                          /**< [out] Returned Error status (see iBase_ErrorType) */
00597 );
00598 
00599 /***************************************************************************/ /**
00600                                                                                * \ingroup EntitySets
00601                                                                                * \brief  Get the
00602                                                                                *number of entities
00603                                                                                *of specified
00604                                                                                *topology in instance
00605                                                                                *or set
00606                                                                                *
00607                                                                                * Get the number of
00608                                                                                *entities with the
00609                                                                                *specified topology
00610                                                                                *in the instance or
00611                                                                                *set.  If entity set
00612                                                                                *handle is root set,
00613                                                                                *return information
00614                                                                                *for instance,
00615                                                                                * otherwise for set.
00616                                                                                *Value of entity
00617                                                                                *topology must be
00618                                                                                *from the
00619                                                                                * iMesh_EntityTopology
00620                                                                                *enumeration.  If
00621                                                                                *iMesh_ALL_TOPOLOGIES
00622                                                                                *is specified, total
00623                                                                                *number of entities
00624                                                                                *(excluding entity
00625                                                                                *sets) is returned.
00626                                                                                ******************************************************************************/
00627 
00628 void iMesh_getNumOfTopo( iMesh_Instance instance,
00629                          /**< [in] iMesh instance handle */
00630                          const iBase_EntitySetHandle entity_set_handle,
00631                          /**< [in] Entity set being queried */
00632                          const int entity_topology,
00633                          /**< [in] Topology of entity requested */
00634                          int* num_topo,
00635                          /**< [out] Pointer to number of entities, returned from function */
00636                          int* err
00637                          /**< [out] Returned Error status (see iBase_ErrorType) */
00638 );
00639 
00640 /***************************************************************************/ /**
00641                                                                                * \ingroup
00642                                                                                *MeshModification
00643                                                                                * \brief Permit
00644                                                                                *implementation to
00645                                                                                *'optimize' the mesh
00646                                                                                *instance
00647                                                                                *
00648                                                                                * Its concievable
00649                                                                                *that after a series
00650                                                                                *of operations
00651                                                                                *modifying the mesh
00652                                                                                * instance, the
00653                                                                                *implementation's
00654                                                                                *internal
00655                                                                                *representation of
00656                                                                                *the mesh may include
00657                                                                                *data and tie up
00658                                                                                *memory resources
00659                                                                                *that could be
00660                                                                                *'optimized' away.
00661                                                                                * For example, if the
00662                                                                                *implementation only
00663                                                                                *marks removed
00664                                                                                *entities for
00665                                                                                *deletion but does
00666                                                                                *not actually free up
00667                                                                                *memory resources
00668                                                                                *associated those
00669                                                                                *entities, a call to
00670                                                                                *this function gives
00671                                                                                *the implementation
00672                                                                                *the 'ok' to go ahead
00673                                                                                *and free up such
00674                                                                                *memory.
00675                                                                                *
00676                                                                                * Depending on the
00677                                                                                *implementation as
00678                                                                                *well as the amount
00679                                                                                *and kind of changes
00680                                                                                * to the mesh that
00681                                                                                *have been made prior
00682                                                                                *to calling it, this
00683                                                                                *call may be very
00684                                                                                *expensive in time
00685                                                                                *complexity. On the
00686                                                                                *other hand, it is
00687                                                                                *also perfectly
00688                                                                                * acceptable that an
00689                                                                                *implementation
00690                                                                                *basically treat this
00691                                                                                *operation as a
00692                                                                                *no-op.
00693                                                                                *
00694                                                                                * In any event, any
00695                                                                                *entity, entity set,
00696                                                                                *iterator or tag
00697                                                                                *handle obtained
00698                                                                                *prior to calling
00699                                                                                *this method will may
00700                                                                                *be invalidated as a
00701                                                                                *result of this call.
00702                                                                                *In that case, the
00703                                                                                *caller must
00704                                                                                *re-acquire handles
00705                                                                                *after making this
00706                                                                                *call. A return
00707                                                                                *argument indicates
00708                                                                                *if handles have been
00709                                                                                *invalidated.
00710                                                                                ******************************************************************************/
00711 
00712 void iMesh_optimize( iMesh_Instance instance,
00713                      /**< [in] iMesh instance handle */
00714                      int* handles_invalidated,
00715                      /**< [out] Returned flag indicating if any handles the caller held
00716                           before calling this function have been invalidated as a result of
00717                           this call. A value of non-zero returned here indicates that any
00718                           handles the caller had prior to this call must not be trusted and
00719                           must be re-acquired by caller. */
00720                      int* err
00721                      /**< [out] Returned Error status (see iBase_ErrorType) */
00722 );
00723 
00724 /***************************************************************************/ /**
00725                                                                                * \ingroup  Entities
00726                                                                                * \brief  Get
00727                                                                                *entities of specific
00728                                                                                *type and/or topology
00729                                                                                *in set or instance
00730                                                                                *
00731                                                                                * Get entities of
00732                                                                                *specific type and/or
00733                                                                                *topology in set or
00734                                                                                *instance.  All
00735                                                                                * entities of a given
00736                                                                                *type or topology are
00737                                                                                *requested by
00738                                                                                *specifying
00739                                                                                * iBase_ALL_TOPOLOGIES
00740                                                                                *or iBase_ALL_TYPES,
00741                                                                                *respectively.
00742                                                                                *Specified type or
00743                                                                                *topology must be a
00744                                                                                *value in the
00745                                                                                *iBase_EntityType or
00746                                                                                *iBase_EntityTopology
00747                                                                                * enumeration,
00748                                                                                *respectively.
00749                                                                                ******************************************************************************/
00750 
00751 void iMesh_getEntities( iMesh_Instance instance,
00752                         /**< [in] iMesh instance handle */
00753                         const iBase_EntitySetHandle entity_set_handle,
00754                         /**< [in] Entity set being queried */
00755                         const int entity_type,
00756                         /**< [in] Type of entities being requested */
00757                         const int entity_topology,
00758                         /**< [in] Topology of entities being requested */
00759                         iBase_EntityHandle** entity_handles,
00760                         /**< [in,out] Pointer to array of entity handles returned \ref trio) */
00761                         int* entity_handles_allocated,
00762                         /**< [in,out] Pointer to allocated size of entity_handles array */
00763                         int* entity_handles_size,
00764                         /**< [out] Pointer to occupied size of entity_handles array */
00765                         int* err
00766                         /**< [out] Returned Error status (see iBase_ErrorType) */
00767 );
00768 
00769 /***************************************************************************/ /**
00770                                                                                * \ingroup
00771                                                                                *VertexEntities
00772                                                                                * \brief  Get
00773                                                                                *coordinates of
00774                                                                                *specified vertices
00775                                                                                *
00776                                                                                * Get coordinates of
00777                                                                                *specified vertices.
00778                                                                                *Coordinates are
00779                                                                                *returned in the
00780                                                                                *storage order
00781                                                                                *indicated by the
00782                                                                                *storage_order
00783                                                                                *argument.
00784                                                                                ******************************************************************************/
00785 
00786 void iMesh_getVtxArrCoords( iMesh_Instance instance,
00787                             /**< [in] iMesh instance handle */
00788                             const iBase_EntityHandle* vertex_handles,
00789                             /**< [in] Array of mesh vertex handles whose coordinates are being
00790                                  requested */
00791                             const int vertex_handles_size,
00792                             /**< [in] Number of vertices in vertex_handles array */
00793                             const int storage_order,
00794                             /**< [in] Requested storage order of returned coordinates
00795                                  (see iBase_StorageOrder) */
00796                             double** coords,
00797                             /**< [in,out] Pointer to array of coordinates returned from function
00798                                  \ref trio) */
00799                             int* coords_allocated,
00800                             /**< [in,out] Pointer to allocated size of coords array */
00801                             int* coords_size,
00802                             /**< [out] Pointer to occupied size of coords array */
00803                             int* err
00804                             /**< [out] Returned Error status (see iBase_ErrorType) */
00805 );
00806 
00807 /***************************************************************************/ /**
00808                                                                                * \ingroup
00809                                                                                *EntityIterators
00810                                                                                * \brief  Initialize
00811                                                                                *an array iterator
00812                                                                                *over specified
00813                                                                                *entity type,
00814                                                                                *topology, and size
00815                                                                                *
00816                                                                                * Initialize an array
00817                                                                                *iterator over
00818                                                                                *specified entity
00819                                                                                *type, topology, and
00820                                                                                * size, for a
00821                                                                                *specified set or
00822                                                                                *instance.  Iterator
00823                                                                                *returned can be used
00824                                                                                * as input to
00825                                                                                *functions returning
00826                                                                                *entities for the
00827                                                                                *iterator.  If all
00828                                                                                * entities of a
00829                                                                                *specified type
00830                                                                                *and/or topology are
00831                                                                                *to be iterated,
00832                                                                                * specify
00833                                                                                *iBase_ALL_TYPES or
00834                                                                                *iMesh_ALL_TOPOLOGIES,
00835                                                                                *respectively.
00836                                                                                * Specified type or
00837                                                                                *topology must be a
00838                                                                                *value in the
00839                                                                                *iBase_EntityType or
00840                                                                                * iMesh_EntityTopology
00841                                                                                *enumerations,
00842                                                                                *respectively.
00843                                                                                ******************************************************************************/
00844 
00845 void iMesh_initEntArrIter( iMesh_Instance instance,
00846                            /**< [in] iMesh instance handle */
00847                            const iBase_EntitySetHandle entity_set_handle,
00848                            /**< [in] Entity set being iterated */
00849                            const int requested_entity_type,
00850                            /**< [in] Type of entity to iterate */
00851                            const int requested_entity_topology,
00852                            /**< [in] Topology of entity to iterate */
00853                            const int requested_array_size,
00854                            /**< [in] Size of chunks of handles returned for each value of the
00855                                 iterator */
00856                            const int resilient,
00857                            /**< [in] If zero, return a non-resilient iterator.
00858                                      Otherwise, a resilient iterator (\ref resilient) */
00859                            iBase_EntityArrIterator* entArr_iterator,
00860                            /**< [out] Pointer to iterator returned from function */
00861                            int* err
00862                            /**< [out] Returned Error status (see iBase_ErrorType) */
00863 );
00864 
00865 /***************************************************************************/ /**
00866                                                                                * \ingroup
00867                                                                                *EntityIterators
00868                                                                                * \brief  Get
00869                                                                                *entities contained
00870                                                                                *in array iterator
00871                                                                                *and increment
00872                                                                                *iterator
00873                                                                                *
00874                                                                                * Get the entities
00875                                                                                *corresponding to an
00876                                                                                *array iterator (e.g.
00877                                                                                *dereference the
00878                                                                                *array iterator), and
00879                                                                                *increment the
00880                                                                                *iterator. The
00881                                                                                *dereferenced
00882                                                                                * value(s) are
00883                                                                                *returned in
00884                                                                                *entity_handles. If
00885                                                                                *the iterator is at
00886                                                                                *the end of the
00887                                                                                *iteration, the
00888                                                                                *dereferenced
00889                                                                                *value(s) are
00890                                                                                *undefined and
00891                                                                                * has_data will be
00892                                                                                *returned with a
00893                                                                                *value of zero.
00894                                                                                *Otherwise, has_data
00895                                                                                * will be returned
00896                                                                                *with a non-zero
00897                                                                                *value.
00898                                                                                ******************************************************************************/
00899 
00900 void iMesh_getNextEntArrIter( iMesh_Instance instance,
00901                               /**< [in] iMesh instance handle */
00902                               iBase_EntityArrIterator entArr_iterator,
00903                               /**< [in] Iterator being queried */
00904                               iBase_EntityHandle** entity_handles,
00905                               /**< [in,out] Pointer to array of entity handles contained in current
00906                                  value of iterator \ref trio) */
00907                               int* entity_handles_allocated,
00908                               /**< [in,out] Pointer to allocated size of entity_handles */
00909                               int* entity_handles_size,
00910                               /**< [out] Pointer to occupied size of entity_handles  */
00911                               int* has_data,
00912                               /**< [out] Pointer to a flag indicating if the value(s) returned
00913                                  in entity_handles are valid. A non-zero value indicates the value(s)
00914                                  are valid. A zero value indicates the value(s) are NOT valid. */
00915                               int* err
00916                               /**< [out] Returned Error status (see iBase_ErrorType) */
00917 );
00918 
00919 /***************************************************************************/ /**
00920                                                                                * \ingroup
00921                                                                                *EntityIterators
00922                                                                                * \brief  Reset the
00923                                                                                *array iterator
00924                                                                                *
00925                                                                                ******************************************************************************/
00926 
00927 void iMesh_resetEntArrIter( iMesh_Instance instance,
00928                             /**< [in] iMesh instance handle */
00929                             iBase_EntityArrIterator entArr_iterator,
00930                             /**< [in] Iterator to reset */
00931                             int* err
00932                             /**< [out] Returned Error status (see iBase_ErrorType) */
00933 );
00934 
00935 /***************************************************************************/ /**
00936                                                                                * \ingroup
00937                                                                                *EntityIterators
00938                                                                                * \brief  Destroy the
00939                                                                                *specified array
00940                                                                                *iterator
00941                                                                                *
00942                                                                                ******************************************************************************/
00943 
00944 void iMesh_endEntArrIter( iMesh_Instance instance,
00945                           /**< [in] iMesh instance handle */
00946                           iBase_EntityArrIterator entArr_iterator,
00947                           /**< [in] Iterator which gets destroyed */
00948                           int* err
00949                           /**< [out] Returned Error status (see iBase_ErrorType) */
00950 );
00951 
00952 /***************************************************************************/ /**
00953                                                                                * \ingroup  Entities
00954                                                                                * \brief  Get the
00955                                                                                *entity topology for
00956                                                                                *the specified
00957                                                                                *entities
00958                                                                                *
00959                                                                                * Get the entity
00960                                                                                *topology for the
00961                                                                                *specified entities.
00962                                                                                *Topologies returned
00963                                                                                *are values in the
00964                                                                                *iMesh_EntityTopology
00965                                                                                *enumeration.
00966                                                                                ******************************************************************************/
00967 
00968 void iMesh_getEntArrTopo( iMesh_Instance instance,
00969                           /**< [in] iMesh instance handle */
00970                           const iBase_EntityHandle* entity_handles,
00971                           /**< [in] Array of entity handles being queried */
00972                           const int entity_handles_size,
00973                           /**< [in] Number of entities in entity_handles array */
00974                           int** topology,
00975                           /**< [in,out] Pointer to array of entity topologies returned
00976                                \ref trio) */
00977                           int* topology_allocated,
00978                           /**< [in,out] Pointer to allocated size of topology array */
00979                           int* topology_size,
00980                           /**< [out] Pointer to occupied size of topology array */
00981                           int* err
00982                           /**< [out] Returned Error status (see iBase_ErrorType) */
00983 );
00984 
00985 /***************************************************************************/ /**
00986                                                                                * \ingroup  Entities
00987                                                                                * \brief  Get the
00988                                                                                *entity type for the
00989                                                                                *specified entities
00990                                                                                *
00991                                                                                * Get the entity type
00992                                                                                *for the specified
00993                                                                                *entities.  Types
00994                                                                                * returned are values
00995                                                                                *in the
00996                                                                                *iBase_EntityType
00997                                                                                *enumeration.
00998                                                                                ******************************************************************************/
00999 
01000 void iMesh_getEntArrType( iMesh_Instance instance,
01001                           /**< [in] iMesh instance handle */
01002                           const iBase_EntityHandle* entity_handles,
01003                           /**< [in] Array of entity handles being queried */
01004                           const int entity_handles_size,
01005                           /**< [in] Number of entities in entity_handles array */
01006                           int** type,
01007                           /**< [in,out] Pointer to array of types returned from function
01008                                \ref trio) */
01009                           int* type_allocated,
01010                           /**< [in,out] Pointer to allocated size of type array */
01011                           int* type_size,
01012                           /**< [out] Pointer to occupied size of type array */
01013                           int* err
01014                           /**< [out] Returned Error status (see iBase_ErrorType) */
01015 );
01016 
01017 /***************************************************************************/ /**
01018                                                                                * \ingroup
01019                                                                                *Adjacencies \brief
01020                                                                                *Get entities of
01021                                                                                *specified type
01022                                                                                *adjacent to entities
01023                                                                                *
01024                                                                                * Get entities of
01025                                                                                *specified type
01026                                                                                *adjacent to
01027                                                                                *entities.  Specified
01028                                                                                *type must be value
01029                                                                                *in the
01030                                                                                *iBase_EntityType
01031                                                                                *enumeration.  \em
01032                                                                                *offset(i) is index
01033                                                                                *of first entity in
01034                                                                                *adjacentEntityHandles
01035                                                                                *array adjacent to
01036                                                                                * entity_handles[i].
01037                                                                                *More precisely, the
01038                                                                                *entities adjacent to
01039                                                                                *the ith entity in
01040                                                                                *entity_handles are
01041                                                                                *found in
01042                                                                                *adjacentEntityHandles
01043                                                                                * running from
01044                                                                                *offset[i] to
01045                                                                                *offset[i+1] - 1.
01046                                                                                *This implies that
01047                                                                                *the offset_size will
01048                                                                                *be
01049                                                                                *entity_handles_size
01050                                                                                *+ 1.
01051                                                                                *
01052                                                                                * Note 1: Because
01053                                                                                *'adjacent' as
01054                                                                                *defined by the iMesh
01055                                                                                *data model refers to
01056                                                                                *those entities that
01057                                                                                *bound another, the
01058                                                                                *entities being
01059                                                                                *queried here (in
01060                                                                                *entity_handles arg)
01061                                                                                *are NEVER ALSO
01062                                                                                *returned in
01063                                                                                *         adjacentEntityHandles
01064                                                                                *even if the
01065                                                                                *entity_type_requested
01066                                                                                *         matches the
01067                                                                                *entity type(s) in
01068                                                                                *entity_handles.
01069                                                                                ******************************************************************************/
01070 
01071 void iMesh_getEntArrAdj( iMesh_Instance instance,
01072                          /**< [in] iMesh instance handle */
01073                          const iBase_EntityHandle* entity_handles,
01074                          /**< [in] Array of entity handles being queried */
01075                          const int entity_handles_size,
01076                          /**< [in] Number of entities in entity_handles array */
01077                          const int entity_type_requested,
01078                          /**< [in] Type of adjacent entities requested */
01079                          iBase_EntityHandle** adjacentEntityHandles,
01080                          /**< [in,out] Pointer to array of adjacentEntityHandles \ref trio)
01081                             returned from function. Note that the implicit INTERLEAVED storage
01082                             order rule applies (see iBase_StorageOrder) */
01083                          int* adjacentEntityHandles_allocated,
01084                          /**< [in,out] Pointer to allocated size of adjacentEntityHandles array */
01085                          int* adj_entity_handles_size,
01086                          /**< [out] Pointer to occupied size of adjacentEntityHandles array */
01087                          int** offset,
01088                          /**< [in,out] Pointer to array of offsets returned from function
01089                               \ref trio) */
01090                          int* offset_allocated,
01091                          /**< [in,out] Pointer to allocated size of offset array */
01092                          int* offset_size,
01093                          /**< [out] Pointer to occupied size of offset array */
01094                          int* err
01095                          /**< [out] Returned Error status (see iBase_ErrorType) */
01096 );
01097 
01098 /***************************************************************************/ /**
01099                                                                                * \ingroup
01100                                                                                *Adjacencies \brief
01101                                                                                *Get "2nd order"
01102                                                                                *adjacencies to an
01103                                                                                *array of entities
01104                                                                                *
01105                                                                                * Get "2nd order"
01106                                                                                *adjacencies to an
01107                                                                                *array of entities,
01108                                                                                *that is, from each
01109                                                                                * entity, through
01110                                                                                *other entities of a
01111                                                                                *specified "bridge"
01112                                                                                *dimension, to other
01113                                                                                * entities of another
01114                                                                                *specified "to"
01115                                                                                *dimension. Note 1:
01116                                                                                *If the "bridge"
01117                                                                                *dimension is the
01118                                                                                *same as the "to"
01119                                                                                *dimension, the
01120                                                                                *output will be empty
01121                                                                                *(and an error code
01122                                                                                *of
01123                                                                                *    iBase_INVALID_ARGUMENT
01124                                                                                *returned).  If the
01125                                                                                *type of a particular
01126                                                                                *    entity matches
01127                                                                                *the "bridge"
01128                                                                                *dimension, there
01129                                                                                *will be no entities
01130                                                                                *    returned for
01131                                                                                *that input entity.
01132                                                                                *This is consistent
01133                                                                                *with the definition
01134                                                                                *of adjacencies and
01135                                                                                *the behavior of
01136                                                                                *iMesh first
01137                                                                                *    adjacency calls.
01138                                                                                * Note 2:  An entity
01139                                                                                *will never be
01140                                                                                *returned as a second
01141                                                                                *adjacency of itself,
01142                                                                                *on the grounds that
01143                                                                                *this is the most
01144                                                                                *likely expectation
01145                                                                                *of applications, and
01146                                                                                *that it is easier
01147                                                                                *for an application
01148                                                                                *to add the original
01149                                                                                *entity to the
01150                                                                                *returned data than
01151                                                                                *to find and remove
01152                                                                                *it. Note 3: The
01153                                                                                *entities adjacent to
01154                                                                                *the ith entity in
01155                                                                                *entity_handles are
01156                                                                                *    found in
01157                                                                                *adj_entity_handles
01158                                                                                *running from
01159                                                                                *offset[i] to
01160                                                                                *    offset[i+1] - 1.
01161                                                                                *This implies that
01162                                                                                *the offset_size will
01163                                                                                *be
01164                                                                                *    entity_handles_size
01165                                                                                *+ 1.
01166                                                                                ******************************************************************************/
01167 
01168 void iMesh_getEntArr2ndAdj( iMesh_Instance instance,
01169                             /**< [in] iMesh instance handle */
01170                             iBase_EntityHandle const* entity_handles,
01171                             /**< [in] Entities from which adjacencies are requested */
01172                             int entity_handles_size,
01173                             /**< [in] Number of entities whose adjacencies are requested */
01174                             int bridge_entity_type,
01175                             /**< [in]  Type of bridge entity for 2nd order adjacencies */
01176                             int requested_entity_type,
01177                             /**< [in] Type of adjacent entities returned */
01178                             iBase_EntityHandle** adj_entity_handles,
01179                             /**< [in,out] Adjacent entities. Note that the implicit INTERLEAVED
01180                                  storage order rule applies (see iBase_StorageOrder)
01181                                  \ref trio) */
01182                             int* adj_entity_handles_allocated,
01183                             /**< [in,out] Allocated size of returned array */
01184                             int* adj_entity_handles_size,
01185                             /**< [out] Occupied size of returned array */
01186                             int** offset,
01187                             /**< [in,out] Offset[i] is offset into adj_entity_handles of 2nd order
01188                                adjacencies of ith entity in entity_handles \ref trio) */
01189                             int* offset_allocated,
01190                             /**< [in,out] Allocated size of offset array */
01191                             int* offset_size,
01192                             /**< [out] Occupied size of offset array */
01193                             int* err
01194                             /**< [out] Returned Error status (see iBase_ErrorType) */
01195 );
01196 
01197 /***************************************************************************/ /**
01198                                                                                * \ingroup
01199                                                                                *Adjacencies \brief
01200                                                                                *Get indexed
01201                                                                                *representation of
01202                                                                                *mesh or subset of
01203                                                                                *mesh
01204                                                                                *
01205                                                                                * Given an entity set
01206                                                                                *and optionally a
01207                                                                                *type or topology,
01208                                                                                *return:
01209                                                                                * - The entities in
01210                                                                                *the set of the
01211                                                                                *specified type or
01212                                                                                *topology
01213                                                                                * - The entities
01214                                                                                *adjacent to those
01215                                                                                *entities with a
01216                                                                                *specified type, as a
01217                                                                                *list of unique
01218                                                                                *handles.
01219                                                                                * - For each entity
01220                                                                                *in the first list,
01221                                                                                *the adjacent
01222                                                                                *entities, specified
01223                                                                                *as indices into the
01224                                                                                *second list.
01225                                                                                *
01226                                                                                * Note 1: Because
01227                                                                                *'adjacent' as
01228                                                                                *defined by the iMesh
01229                                                                                *data model refers to
01230                                                                                *those entities that
01231                                                                                *bound another, the
01232                                                                                *entities being
01233                                                                                *queried here (in
01234                                                                                *entity_set_handle
01235                                                                                *arg) are NEVER ALSO
01236                                                                                *returned in
01237                                                                                *         adj_entity_handles
01238                                                                                *even if the
01239                                                                                *entity_type_requested
01240                                                                                *         matches the
01241                                                                                *entity type(s) in
01242                                                                                *entity_set_handle.
01243                                                                                * Note 2: The
01244                                                                                *entities adjacent to
01245                                                                                *the ith entity in
01246                                                                                *entity_handles are
01247                                                                                *         found in
01248                                                                                *adj_entity_handles
01249                                                                                *running from
01250                                                                                *offset[i] to
01251                                                                                *         offset[i+1]
01252                                                                                *- 1.  This implies
01253                                                                                *that the offset_size
01254                                                                                *will be
01255                                                                                *entity_handles_size
01256                                                                                *+ 1. Note 3: This
01257                                                                                *function will fail
01258                                                                                *and return an error
01259                                                                                *if the caller passes
01260                                                                                *         a
01261                                                                                *combination of
01262                                                                                *entity_type and
01263                                                                                *entity_topology that
01264                                                                                *are not consistent.
01265                                                                                ******************************************************************************/
01266 
01267 void iMesh_getAdjEntIndices( iMesh_Instance instance,
01268                              /**< [in] iMesh instance handle */
01269                              iBase_EntitySetHandle entity_set_handle,
01270                              /**< [in] The set of entities from which to query */
01271                              int entity_type_requester,
01272                              /**< [in] If not iBase_ALL_TYPES, act only on the subset of entities
01273                                 contained in entity_set_handle of the specified type. */
01274                              int entity_topology_requester,
01275                              /**< [in] If not iMesh_ALL_TOPOLOGIES, act only on the subset of
01276                                 entities contained in entity_set_handle of specified topology. */
01277                              int entity_type_requested,
01278                              /**< [in] The type of the adjacent entities to return */
01279                              iBase_EntityHandle** entity_handles,
01280                              /**< [in,out] The handles of the (non-struct) subset of the entities
01281                                   contained in entity_set_handle indicated by the optional type and
01282                                   topology filtering arguments. \ref trio) */
01283                              int* entity_handles_allocated,
01284                              /**< [in,out] Allocated size of entity_handles array */
01285                              int* entity_handles_size,
01286                              /**< [out] Occupied size of entity_handles array */
01287                              iBase_EntityHandle** adj_entity_handles,
01288                              /**< [in,out] The union of the unique entities of type
01289                                 requested_entity_type adjacent to each entity in entity_handles.
01290                                 Note that the implicit INTERLEAVED storage order rule
01291                                 applies (see iBase_StorageOrder) \ref trio) */
01292                              int* adj_entity_handles_allocated,
01293                              /**< [in,out] Allocated size of adj_entity_handles array */
01294                              int* adj_entity_handles_size,
01295                              /**< [out] Occupied size of adj_entity_handles array */
01296                              int** adj_entity_indices,
01297                              /**< [in,out] For each entity in entity_handles, the adjacent
01298                                 entities of type entity_type_requested, specified as indices into
01299                                 adj_entity_handles.  The values are concatenated into a single
01300                                 array in the order of the entity handles in entity_handles.
01301                                 \ref trio) */
01302                              int* adj_entity_indices_allocated,
01303                              /**< [in,out] Allocated size of adj_entity_indices array */
01304                              int* adj_entity_indices_size,
01305                              /**< [out] Occupied size of adj_entity_indices array */
01306                              int** offset,
01307                              /**< [in,out] For each entity in the corresponding position in
01308                                 entity_handles, the position in adj_entity_indices at which
01309                                 values for that entity are stored \ref trio) */
01310                              int* offset_allocated,
01311                              /**< [in,out] Allocated size of offset array */
01312                              int* offset_size,
01313                              /**< [out] Occipied size of offset array */
01314                              int* err
01315                              /**< [out] Returned Error status (see iBase_ErrorType) */
01316 );
01317 
01318 /***************************************************************************/ /**
01319                                                                                * \ingroup EntitySets
01320                                                                                * \brief  Create an
01321                                                                                *entity set
01322                                                                                *
01323                                                                                * Create an entity
01324                                                                                *set, either ordered
01325                                                                                *(isList=1) or
01326                                                                                *unordered
01327                                                                                *(isList=0).
01328                                                                                * Unordered entity
01329                                                                                *sets can contain a
01330                                                                                *given entity or set
01331                                                                                *only once.
01332                                                                                *
01333                                                                                * An entity set in
01334                                                                                *iMesh supports
01335                                                                                *managing its
01336                                                                                *contained members in
01337                                                                                *one of two modes.
01338                                                                                *When an entitiy set
01339                                                                                *is first created,
01340                                                                                *the caller is
01341                                                                                *required to indicate
01342                                                                                *which mode of
01343                                                                                *membership the set
01344                                                                                *will support. The
01345                                                                                *two modes that are
01346                                                                                *supported are a)
01347                                                                                *order-preserving
01348                                                                                *(isList=1) or b)
01349                                                                                *duplicate-preventing
01350                                                                                *(isList=0).
01351                                                                                *
01352                                                                                * For
01353                                                                                *order-preserving
01354                                                                                *membership, the
01355                                                                                *implementation will
01356                                                                                *permit duplicate
01357                                                                                * entities. However,
01358                                                                                *the implementation
01359                                                                                *will guarantee that
01360                                                                                *the order in which
01361                                                                                * entities are added
01362                                                                                *to the set will be
01363                                                                                *the same as the
01364                                                                                *order in which they
01365                                                                                *are queried by the
01366                                                                                *various methods that
01367                                                                                *return the entities
01368                                                                                *of a set. This order
01369                                                                                * preserving
01370                                                                                *guarantee holds
01371                                                                                *across removals.
01372                                                                                *However, it does not
01373                                                                                *hold across removals
01374                                                                                *followed by
01375                                                                                *re-additions of the
01376                                                                                *previously removed
01377                                                                                *entities. This kind
01378                                                                                *of an entity set
01379                                                                                *behaves like an STL
01380                                                                                *vector or STL list
01381                                                                                *and is created by
01382                                                                                *setting isList=1
01383                                                                                *when creating an
01384                                                                                *entity set.
01385                                                                                *
01386                                                                                * For
01387                                                                                *duplicate-preventing
01388                                                                                *membership, the
01389                                                                                *implementation will
01390                                                                                *guarantee that
01391                                                                                * duplicate entities
01392                                                                                *are prevented. Any
01393                                                                                *attempts to add
01394                                                                                *duplicate entities
01395                                                                                *to such a set will
01396                                                                                *be detected,
01397                                                                                *prevented and
01398                                                                                *silently ignored by
01399                                                                                *the implementation.
01400                                                                                *This kind of entity
01401                                                                                *set behaves like an
01402                                                                                *STL set and is
01403                                                                                *created by setting
01404                                                                                *isList=0 when
01405                                                                                *creating an entity
01406                                                                                *set.
01407                                                                                *
01408                                                                                * Finally, all of the
01409                                                                                *above comments apply
01410                                                                                *only to entity
01411                                                                                *members of an entity
01412                                                                                * set and do not
01413                                                                                *apply to the entity
01414                                                                                *set members.
01415                                                                                *Order-preserving and
01416                                                                                * duplicate
01417                                                                                *preventing behavior
01418                                                                                *for entity set
01419                                                                                *members is
01420                                                                                *unspecified. Each
01421                                                                                * implementation may
01422                                                                                *behave differently
01423                                                                                *for entity set
01424                                                                                *members. This design
01425                                                                                *was chosen because
01426                                                                                *we could not
01427                                                                                *identify any use
01428                                                                                *cases where
01429                                                                                * order-preserving
01430                                                                                *behavior for set
01431                                                                                *members was
01432                                                                                *necessary. However,
01433                                                                                *if users encounter
01434                                                                                *situations where
01435                                                                                *such behavior is
01436                                                                                *desirable or
01437                                                                                *necessary, then the
01438                                                                                *ITAPS development
01439                                                                                *team can certainly
01440                                                                                *consider adjusting
01441                                                                                *the interface
01442                                                                                * specification to
01443                                                                                *support it.
01444                                                                                ******************************************************************************/
01445 
01446 void iMesh_createEntSet( iMesh_Instance instance,
01447                          /**< [in] iMesh instance handle */
01448                          const int isList,
01449                          /**< [in] If non-zero, an ordered list is created, otherwise an
01450                             unordered set is created. */
01451                          iBase_EntitySetHandle* entity_set_created,
01452                          /**< [out] Entity set created by function */
01453                          int* err
01454                          /**< [out] Returned Error status (see iBase_ErrorType) */
01455 );
01456 
01457 /***************************************************************************/ /**
01458                                                                                * \ingroup EntitySets
01459                                                                                * \brief  Destroy an
01460                                                                                *entity set
01461                                                                                *
01462                                                                                ******************************************************************************/
01463 
01464 void iMesh_destroyEntSet( iMesh_Instance instance,
01465                           /**< [in] iMesh instance handle */
01466                           iBase_EntitySetHandle entity_set,
01467                           /**< [in] Entity set to be destroyed */
01468                           int* err
01469                           /**< [out] Returned Error status (see iBase_ErrorType) */
01470 );
01471 
01472 /***************************************************************************/ /**
01473                                                                                * \ingroup EntitySets
01474                                                                                * \brief  Return
01475                                                                                *whether a specified
01476                                                                                *set is ordered or
01477                                                                                *unordered
01478                                                                                *
01479                                                                                * Return whether a
01480                                                                                *specified set is
01481                                                                                *ordered (*is_list=1)
01482                                                                                *or unordered
01483                                                                                *(*is_list=0)
01484                                                                                ******************************************************************************/
01485 
01486 void iMesh_isList( iMesh_Instance instance,
01487                    /**< [in] iMesh instance handle */
01488                    const iBase_EntitySetHandle entity_set,
01489                    /**< [in] Entity set being queried */
01490                    int* is_list,
01491                    /**< [out] Pointer to flag returned from function */
01492                    int* err
01493                    /**< [out] Returned Error status (see iBase_ErrorType) */
01494 );
01495 
01496 /***************************************************************************/ /**
01497                                                                                * \ingroup EntitySets
01498                                                                                * \brief  Get the
01499                                                                                *number of entity
01500                                                                                *sets contained in a
01501                                                                                *set or interface
01502                                                                                *
01503                                                                                * Get the number of
01504                                                                                *entity sets
01505                                                                                *contained in a set
01506                                                                                *or interface.
01507                                                                                ******************************************************************************/
01508 
01509 void iMesh_getNumEntSets( iMesh_Instance instance,
01510                           /**< [in] iMesh instance handle */
01511                           const iBase_EntitySetHandle entity_set_handle,
01512                           /**< [in] Entity set being queried */
01513                           const int num_hops,
01514                           /**< [in] Maximum hops from entity_set_handle to contained set, not
01515                                inclusive of the contained set.  \ref numhops) */
01516                           int* num_sets,
01517                           /**< [out] Pointer to the number of sets returned from function */
01518                           int* err
01519                           /**< [out] Returned Error status (see iBase_ErrorType) */
01520 );
01521 
01522 /***************************************************************************/ /**
01523                                                                                * \ingroup EntitySets
01524                                                                                * \brief  Get the
01525                                                                                *entity sets
01526                                                                                *contained in a set
01527                                                                                *or interface
01528                                                                                *
01529                                                                                * Get the entity sets
01530                                                                                *contained in a set
01531                                                                                *or interface.
01532                                                                                ******************************************************************************/
01533 
01534 void iMesh_getEntSets( iMesh_Instance instance,
01535                        /**< [in] iMesh instance handle */
01536                        const iBase_EntitySetHandle entity_set_handle,
01537                        /**< [in] Entity set being queried */
01538                        const int num_hops,
01539                        /**< [in] Maximum hops from entity_set_handle to contained set, not
01540                           inclusive of the contained set \ref numhops) */
01541                        iBase_EntitySetHandle** contained_set_handles,
01542                        /**< [in,out] Pointer to array of set handles returned \ref trio) */
01543                        int* contained_set_handles_allocated,
01544                        /**< [in,out] Pointer to allocated length of */
01545                        int* contained_set_handles_size,
01546                        /**< [out] Pointer to occupied length of */
01547                        int* err
01548                        /**< [out] Returned Error status (see iBase_ErrorType) */
01549 );
01550 
01551 /***************************************************************************/ /**
01552                                                                                * \ingroup EntitySets
01553                                                                                * \brief  Add an
01554                                                                                *entity to a set
01555                                                                                *
01556                                                                                ******************************************************************************/
01557 
01558 void iMesh_addEntToSet( iMesh_Instance instance,
01559                         /**< [in] iMesh instance handle */
01560                         iBase_EntityHandle entity_handle,
01561                         /**< [in] The entity being added */
01562                         iBase_EntitySetHandle entity_set,
01563                         /**< [in] Pointer to the set being added to */
01564                         int* err
01565                         /**< [out] Returned Error status (see iBase_ErrorType) */
01566 );
01567 
01568 /***************************************************************************/ /**
01569                                                                                * \ingroup EntitySets
01570                                                                                * \brief  Remove an
01571                                                                                *entity from a set
01572                                                                                *
01573                                                                                ******************************************************************************/
01574 
01575 void iMesh_rmvEntFromSet( iMesh_Instance instance,
01576                           /**< [in] iMesh instance handle */
01577                           iBase_EntityHandle entity_handle,
01578                           /**< [in] The entity being removed */
01579                           iBase_EntitySetHandle entity_set,
01580                           /**< [in] Pointer to the set being removed from */
01581                           int* err
01582                           /**< [out] Returned Error status (see iBase_ErrorType) */
01583 );
01584 
01585 /***************************************************************************/ /**
01586                                                                                * \ingroup EntitySets
01587                                                                                * \brief  Add an
01588                                                                                *array of entities to
01589                                                                                *a set
01590                                                                                *
01591                                                                                ******************************************************************************/
01592 
01593 void iMesh_addEntArrToSet( iMesh_Instance instance,
01594                            /**< [in] iMesh instance handle */
01595                            const iBase_EntityHandle* entity_handles,
01596                            /**< [in] Array of entities being added */
01597                            int entity_handles_size,
01598                            /**< [in] Number of entities in entity_handles array */
01599                            iBase_EntitySetHandle entity_set,
01600                            /**< [in] Pointer to the set being added to */
01601                            int* err
01602                            /**< [out] Returned Error status (see iBase_ErrorType) */
01603 );
01604 
01605 /***************************************************************************/ /**
01606                                                                                * \ingroup EntitySets
01607                                                                                * \brief  Remove an
01608                                                                                *array of entities
01609                                                                                *from a set
01610                                                                                *
01611                                                                                ******************************************************************************/
01612 
01613 void iMesh_rmvEntArrFromSet( iMesh_Instance instance,
01614                              /**< [in] iMesh instance handle */
01615                              const iBase_EntityHandle* entity_handles,
01616                              /**< [in] Array of entities being remove */
01617                              int entity_handles_size,
01618                              /**< [in] Number of entities in entity_handles array */
01619                              iBase_EntitySetHandle entity_set,
01620                              /**< [in] Pointer to the set being removed from */
01621                              int* err
01622                              /**< [out] Returned Error status (see iBase_ErrorType) */
01623 );
01624 
01625 /***************************************************************************/ /**
01626                                                                                * \ingroup EntitySets
01627                                                                                * \brief  Add an
01628                                                                                *entity set to a set
01629                                                                                *
01630                                                                                * Add an entity set
01631                                                                                *to a set (\ref
01632                                                                                *cycles)
01633                                                                                ******************************************************************************/
01634 
01635 void iMesh_addEntSet( iMesh_Instance instance,
01636                       /**< [in] iMesh instance handle */
01637                       iBase_EntitySetHandle entity_set_to_add,
01638                       /**< [in] The entity set being added */
01639                       iBase_EntitySetHandle entity_set_handle,
01640                       /**< [in] Pointer to the set being added to */
01641                       int* err
01642                       /**< [out] Returned Error status (see iBase_ErrorType) */
01643 );
01644 
01645 /***************************************************************************/ /**
01646                                                                                * \ingroup EntitySets
01647                                                                                * \brief  Remove an
01648                                                                                *entity set from a
01649                                                                                *set
01650                                                                                *
01651                                                                                * Remove an entity
01652                                                                                *set from a set
01653                                                                                ******************************************************************************/
01654 
01655 void iMesh_rmvEntSet( iMesh_Instance instance,
01656                       /**< [in] iMesh instance handle */
01657                       iBase_EntitySetHandle entity_set_to_remove,
01658                       /**< [in] The entity set being removed */
01659                       iBase_EntitySetHandle entity_set_handle,
01660                       /**< [in] Pointer to the set being removed from */
01661                       int* err
01662                       /**< [out] Returned Error status (see iBase_ErrorType) */
01663 );
01664 
01665 /***************************************************************************/ /**
01666                                                                                * \ingroup EntitySets
01667                                                                                * \brief  Return
01668                                                                                *whether an entity is
01669                                                                                *contained in another
01670                                                                                *set
01671                                                                                *
01672                                                                                * Return whether an
01673                                                                                *entity is contained
01674                                                                                *(*is_contained=1) or
01675                                                                                *not contained
01676                                                                                *(*is_contained=0) in
01677                                                                                *another set
01678                                                                                ******************************************************************************/
01679 
01680 void iMesh_isEntContained( iMesh_Instance instance,
01681                            /**< [in] iMesh instance handle */
01682                            iBase_EntitySetHandle containing_entity_set,
01683                            /**< [in] Entity set being queried */
01684                            iBase_EntityHandle contained_entity,
01685                            /**< [in] Entity potentially contained in containing_entity_set */
01686                            int* is_contained,
01687                            /**< [out] Pointer to flag returned from function */
01688                            int* err
01689                            /**< [out] Returned Error status (see iBase_ErrorType) */
01690 );
01691 
01692 /***************************************************************************/ /**
01693                                                                                * \ingroup EntitySets
01694                                                                                * \brief  Return
01695                                                                                *whether entities are
01696                                                                                *contained in a set
01697                                                                                *
01698                                                                                ******************************************************************************/
01699 
01700 void iMesh_isEntArrContained( iMesh_Instance instance,
01701                               /**< [in] iMesh instance handle */
01702                               iBase_EntitySetHandle containing_entity_set,
01703                               /**< [in] Entity set being queried */
01704                               const iBase_EntityHandle* entity_handles,
01705                               /**< [in] List of entities for which to check containment. */
01706                               int num_entity_handles,
01707                               /**< [in] Size of entity_handles array of entities to be checked. */
01708                               int** is_contained,
01709                               /**< [in,out] One value for each input entity, 1 if contained in set,
01710                                    zero otherwise.  \ref trio) */
01711                               int* is_contained_allocated,
01712                               /**< [in,out] Allocated size of is_contained array */
01713                               int* is_contained_size,
01714                               /**< [out] Occupied size of is_contained array */
01715                               int* err
01716                               /**< [out] Returned Error status (see iBase_ErrorType) */
01717 );
01718 
01719 /***************************************************************************/ /**
01720                                                                                * \ingroup EntitySets
01721                                                                                * \brief  Return
01722                                                                                *whether an entity
01723                                                                                *set is contained in
01724                                                                                *another set
01725                                                                                *
01726                                                                                * Return whether a
01727                                                                                *set is contained
01728                                                                                *(*is_contained=1) or
01729                                                                                *not contained
01730                                                                                * (*is_contained=0)
01731                                                                                *in another set
01732                                                                                ******************************************************************************/
01733 
01734 void iMesh_isEntSetContained( iMesh_Instance instance,
01735                               /**< [in] iMesh instance handle */
01736                               const iBase_EntitySetHandle containing_entity_set,
01737                               /**< [in] Entity set being queried */
01738                               const iBase_EntitySetHandle contained_entity_set,
01739                               /**< [in] Entity set potentially contained in containing_entity_set */
01740                               int* is_contained,
01741                               /**< [out] Pointer to flag returned from function */
01742                               int* err
01743                               /**< [out] Returned Error status (see iBase_ErrorType) */
01744 );
01745 
01746 /***************************************************************************/ /**
01747                                                                                * \ingroup
01748                                                                                *ParentChildLinks
01749                                                                                * \brief  Add
01750                                                                                *parent/child links
01751                                                                                *between two sets
01752                                                                                *
01753                                                                                * Add parent/child
01754                                                                                *links between two
01755                                                                                *sets.  Makes parent
01756                                                                                *point to child and
01757                                                                                *child point to
01758                                                                                *parent. (\ref
01759                                                                                *cycles)
01760                                                                                ******************************************************************************/
01761 
01762 void iMesh_addPrntChld( iMesh_Instance instance,
01763                         /**< [in] iMesh instance handle */
01764                         iBase_EntitySetHandle parent_entity_set,
01765                         /**< [in] Pointer to parent set */
01766                         iBase_EntitySetHandle child_entity_set,
01767                         /**< [in] Pointer to child set */
01768                         int* err
01769                         /**< [out] Returned Error status (see iBase_ErrorType) */
01770 );
01771 
01772 /***************************************************************************/ /**
01773                                                                                * \ingroup
01774                                                                                *ParentChildLinks
01775                                                                                * \brief  Remove
01776                                                                                *parent/child links
01777                                                                                *between two sets
01778                                                                                *
01779                                                                                * Remove parent/child
01780                                                                                *links between two
01781                                                                                *sets.
01782                                                                                ******************************************************************************/
01783 
01784 void iMesh_rmvPrntChld( iMesh_Instance instance,
01785                         /**< [in] iMesh instance handle */
01786                         iBase_EntitySetHandle parent_entity_set,
01787                         /**< [in] Pointer to parent set */
01788                         iBase_EntitySetHandle child_entity_set,
01789                         /**< [in] Pointer to child set */
01790                         int* err
01791                         /**< [out] Returned Error status (see iBase_ErrorType) */
01792 );
01793 
01794 /***************************************************************************/ /**
01795                                                                                * \ingroup
01796                                                                                *ParentChildLinks
01797                                                                                * \brief  Return
01798                                                                                *whether two sets are
01799                                                                                *related by
01800                                                                                *parent/child links
01801                                                                                *
01802                                                                                * Return whether two
01803                                                                                *sets are related
01804                                                                                *(*is_child=1) or not
01805                                                                                *(*is_child=0) by
01806                                                                                *parent/child links
01807                                                                                ******************************************************************************/
01808 
01809 void iMesh_isChildOf( iMesh_Instance instance,
01810                       /**< [in] iMesh instance handle */
01811                       const iBase_EntitySetHandle parent_entity_set,
01812                       /**< [in] Pointer to parent set */
01813                       const iBase_EntitySetHandle child_entity_set,
01814                       /**< [in] Pointer to child set */
01815                       int* is_child,
01816                       /**< [out] Pointer to flag returned from function */
01817                       int* err
01818                       /**< [out] Returned Error status (see iBase_ErrorType) */
01819 );
01820 
01821 /***************************************************************************/ /**
01822                                                                                * \ingroup
01823                                                                                *ParentChildLinks
01824                                                                                * \brief  Get the
01825                                                                                *number of child sets
01826                                                                                *linked from a
01827                                                                                *specified set
01828                                                                                *
01829                                                                                * Get the number of
01830                                                                                *child sets linked
01831                                                                                *from a specified
01832                                                                                *set.
01833                                                                                ******************************************************************************/
01834 
01835 void iMesh_getNumChld( iMesh_Instance instance,
01836                        /**< [in] iMesh instance handle */
01837                        const iBase_EntitySetHandle entity_set,
01838                        /**< [in] Entity set being queried */
01839                        const int num_hops,
01840                        /**< [in] Maximum hops from entity_set_handle to child set, not
01841                           inclusive of the child set.  \ref numhops) */
01842                        int* num_child,
01843                        /**< [out] Pointer to number of children returned from function */
01844                        int* err
01845                        /**< [out] Returned Error status (see iBase_ErrorType) */
01846 );
01847 
01848 /***************************************************************************/ /**
01849                                                                                * \ingroup
01850                                                                                *ParentChildLinks
01851                                                                                * \brief  Get the
01852                                                                                *number of parent
01853                                                                                *sets linked from a
01854                                                                                *specified set
01855                                                                                *
01856                                                                                * Get the number of
01857                                                                                *parent sets linked
01858                                                                                *from a specified
01859                                                                                *set.
01860                                                                                ******************************************************************************/
01861 
01862 void iMesh_getNumPrnt( iMesh_Instance instance,
01863                        /**< [in] iMesh instance handle */
01864                        const iBase_EntitySetHandle entity_set,
01865                        /**< [in] Entity set being queried */
01866                        const int num_hops,
01867                        /**< [in] Maximum hops from entity_set_handle to parent set, not
01868                           inclusive of the parent set.  \ref numhops) */
01869                        int* num_parent,
01870                        /**< [out] Pointer to number of parents returned from function */
01871                        int* err
01872                        /**< [out] Returned Error status (see iBase_ErrorType) */
01873 );
01874 
01875 /***************************************************************************/ /**
01876                                                                                * \ingroup
01877                                                                                *ParentChildLinks
01878                                                                                * \brief  Get the
01879                                                                                *child sets linked
01880                                                                                *from a specified set
01881                                                                                *
01882                                                                                * Get the child sets
01883                                                                                *linked from a
01884                                                                                *specified set.
01885                                                                                ******************************************************************************/
01886 
01887 void iMesh_getChldn( iMesh_Instance instance,
01888                      /**< [in] iMesh instance handle */
01889                      const iBase_EntitySetHandle from_entity_set,
01890                      /**< [in] Entity set being queried */
01891                      const int num_hops,
01892                      /**< [in] Maximum hops from entity_set_handle to child set,
01893                         \ref numhops) */
01894                      iBase_EntitySetHandle** entity_set_handles,
01895                      /**< [in,out] Pointer to array of child sets \ref trio) */
01896                      int* entity_set_handles_allocated,
01897                      /**< [in,out] Pointer to allocated size of  */
01898                      int* entity_set_handles_size,
01899                      /**< [out] Pointer to occupied size of  */
01900                      int* err
01901                      /**< [out] Returned Error status (see iBase_ErrorType) */
01902 );
01903 
01904 /***************************************************************************/ /**
01905                                                                                * \ingroup
01906                                                                                *ParentChildLinks
01907                                                                                * \brief  Get the
01908                                                                                *parent sets linked
01909                                                                                *from a specified set
01910                                                                                *
01911                                                                                * Get the parent sets
01912                                                                                *linked from a
01913                                                                                *specified set.
01914                                                                                ******************************************************************************/
01915 
01916 void iMesh_getPrnts( iMesh_Instance instance,
01917                      /**< [in] iMesh instance handle */
01918                      const iBase_EntitySetHandle from_entity_set,
01919                      /**< [in] Entity set being queried */
01920                      const int num_hops,
01921                      /**< [in] Maximum hops from entity_set_handle to parent set,
01922                         \ref numhops) */
01923                      iBase_EntitySetHandle** entity_set_handles,
01924                      /**< [in,out] Pointer to array of parent sets \ref trio) */
01925                      int* entity_set_handles_allocated,
01926                      /**< [in,out] Pointer to allocated size of  */
01927                      int* entity_set_handles_size,
01928                      /**< [out] Pointer to occupied size of  */
01929                      int* err
01930                      /**< [out] Returned Error status (see iBase_ErrorType) */
01931 );
01932 
01933 /***************************************************************************/ /**
01934                                                                                * \ingroup
01935                                                                                *VertexEntities
01936                                                                                * \brief  Set
01937                                                                                *coordinates for an
01938                                                                                *array of vertices
01939                                                                                *
01940                                                                                * Set coordinates for
01941                                                                                *an array of
01942                                                                                *vertices.  Specified
01943                                                                                *storage order must
01944                                                                                *be either
01945                                                                                *iBase_INTERLEAVED or
01946                                                                                *iBase_BLOCKED, and
01947                                                                                * indicates order of
01948                                                                                *x, y, and z
01949                                                                                *coordinates in
01950                                                                                *coordinate array.
01951                                                                                ******************************************************************************/
01952 
01953 void iMesh_setVtxArrCoords( iMesh_Instance instance,
01954                             /**< [in] iMesh instance handle */
01955                             const iBase_EntityHandle* vertex_handles,
01956                             /**< [in] Array of vertex handles */
01957                             const int vertex_handles_size,
01958                             /**< [in] Number of vertex handles in array */
01959                             const int storage_order,
01960                             /**< [in] Storage order of coordinates in coordinate array */
01961                             const double* new_coords,
01962                             /**< [in] Coordinate array */
01963                             const int new_coords_size,
01964                             /**< [in] Size of coordinate array; should be  */
01965                             int* err
01966                             /**< [out] Returned Error status (see iBase_ErrorType) */
01967 );
01968 
01969 /***************************************************************************/ /**
01970                                                                                * \ingroup
01971                                                                                *VertexEntities
01972                                                                                * \brief  Create an
01973                                                                                *array of new
01974                                                                                *vertices at
01975                                                                                *specified
01976                                                                                *coordinates
01977                                                                                *
01978                                                                                * Create an array of
01979                                                                                *new vertices at
01980                                                                                *specified
01981                                                                                *coordinates.  Value
01982                                                                                *of storage_order
01983                                                                                *must be either
01984                                                                                *iBase_INTERLEAVED or
01985                                                                                *iBase_BLOCKED.
01986                                                                                ******************************************************************************/
01987 
01988 void iMesh_createVtxArr( iMesh_Instance instance,
01989                          /**< [in] iMesh instance handle */
01990                          const int num_verts,
01991                          /**< [in] Number of new vertices to be created */
01992                          const int storage_order,
01993                          /**< [in] Storage order of coordinates in new_coords array
01994                               (see iBase_StorageOrder) */
01995                          const double* new_coords,
01996                          /**< [in] Array of coordinates of new vertices. Should be G*num_verts
01997                             in length where G is geometric dimension of the mesh. */
01998                          const int new_coords_size,
01999                          /**< [in] Number of coordinates in new_coords array, should */
02000                          iBase_EntityHandle** new_vertex_handles,
02001                          /**< [in,out] Pointer to array of new vertex handles \ref trio) */
02002                          int* new_vertex_handles_allocated,
02003                          /**< [in,out] Pointer to allocated size of  */
02004                          int* new_vertex_handles_size,
02005                          /**< [out] Pointer to occupied size of  */
02006                          int* err
02007                          /**< [out] Returned Error status (see iBase_ErrorType) */
02008 );
02009 
02010 /***************************************************************************/ /**
02011                                                                                * \ingroup  Entities
02012                                                                                * \brief  Create an
02013                                                                                *array of new
02014                                                                                *entities with
02015                                                                                *specified
02016                                                                                *lower-order topology
02017                                                                                *
02018                                                                                * Create an array of
02019                                                                                *new entities with
02020                                                                                *specified
02021                                                                                *lower-order
02022                                                                                *topology. Specified
02023                                                                                *new_entity_topology
02024                                                                                *must be value in
02025                                                                                *iMesh_EntityTopology
02026                                                                                * enumeration. Values
02027                                                                                *return in status
02028                                                                                *array must be values
02029                                                                                *in the
02030                                                                                * iBase_CreationStatus
02031                                                                                *enumeration.
02032                                                                                ******************************************************************************/
02033 
02034 void iMesh_createEntArr( iMesh_Instance instance,
02035                          /**< [in] iMesh instance handle */
02036                          const int new_entity_topology,
02037                          /**< [in] Topology of created entity */
02038                          const iBase_EntityHandle* lower_order_entity_handles,
02039                          /**< [in] Array of lower order entity handles to be used to construct
02040                               new entities */
02041                          const int lower_order_entity_handles_size,
02042                          /**< [in] Number of entities in lower_order_entity_handles array */
02043                          iBase_EntityHandle** new_entity_handles,
02044                          /**< [in,out] Pointer to array of new_entity_handles
02045                               \ref trio) */
02046                          int* new_entity_handles_allocated,
02047                          /**< [in,out] Pointer to allocated size of  */
02048                          int* new_entity_handles_size,
02049                          /**< [out] Pointer to occupied size of  */
02050                          int** status,
02051                          /**< [in,out] Pointer to array of creation status returned from
02052                             \ref trio) (see iBase_CreationStatus) */
02053                          int* status_allocated,
02054                          /**< [in,out] Pointer to allocated size of status array */
02055                          int* status_size,
02056                          /**< [out] Pointer to occupied size of status array */
02057                          int* err
02058                          /**< [out] Returned Error status (see iBase_ErrorType) */
02059 );
02060 
02061 /***************************************************************************/ /**
02062                                                                                * \ingroup  Entities
02063                                                                                * \brief  Delete
02064                                                                                *specified entities
02065                                                                                *
02066                                                                                * Delete specified
02067                                                                                *entities
02068                                                                                ******************************************************************************/
02069 
02070 void iMesh_deleteEntArr( iMesh_Instance instance,
02071                          /**< [in] iMesh instance handle */
02072                          const iBase_EntityHandle* entity_handles,
02073                          /**< [in] Array of entity handles to be deleted */
02074                          const int entity_handles_size,
02075                          /**< [in] Number of entities in array to be deleted */
02076                          int* err
02077                          /**< [out] Returned Error status (see iBase_ErrorType) */
02078 );
02079 
02080 /***************************************************************************/ /**
02081                                                                                * \ingroup  Tags
02082                                                                                * \brief  Create a
02083                                                                                *tag with specified
02084                                                                                *name, size, and type
02085                                                                                *
02086                                                                                * Create a tag with
02087                                                                                *specified name,
02088                                                                                *size, and type.  Tag
02089                                                                                *size is in units of
02090                                                                                *size of tag_type
02091                                                                                *data types.  Value
02092                                                                                *input for tag type
02093                                                                                *must be value in
02094                                                                                *iBase_TagType
02095                                                                                *enumeration.
02096                                                                                ******************************************************************************/
02097 
02098 void iMesh_createTag( iMesh_Instance instance,
02099                       /**< [in] iMesh instance handle */
02100                       const char* tag_name,
02101                       /**< [in] Character string indicating tag name */
02102                       const int tag_size,
02103                       /**< [in] Size of each tag value, in units of number of
02104                            tag_type datums. */
02105                       const int tag_type,
02106                       /**< [in] Data type for data stored in this tag */
02107                       iBase_TagHandle* tag_handle,
02108                       /**< [out] Pointer to tag handle returned from function */
02109                       int* err,
02110                       /**< [out] Returned Error status (see iBase_ErrorType) */
02111                       const int tag_name_len
02112                       /**< [in] Length of tag name string (\ref strlen) */
02113 );
02114 
02115 /***************************************************************************/ /**
02116                                                                                * \ingroup  Tags
02117                                                                                * \brief  Destroy a
02118                                                                                *tag
02119                                                                                *
02120                                                                                * Destroy a tag.  If
02121                                                                                *forced is non-zero
02122                                                                                *and entities still
02123                                                                                *have values set for
02124                                                                                *this tag, tag is
02125                                                                                *deleted anyway and
02126                                                                                *those values
02127                                                                                *disappear, otherwise
02128                                                                                *tag is not deleted.
02129                                                                                ******************************************************************************/
02130 
02131 void iMesh_destroyTag( iMesh_Instance instance,
02132                        /**< [in] iMesh instance handle */
02133                        iBase_TagHandle tag_handle,
02134                        /**< [in] Handle of tag to be deleted */
02135                        const int forced,
02136                        /**< [in] If non-zero, delete the tag even if entities have values set
02137                           for the tag. */
02138                        int* err
02139                        /**< [out] Returned Error status (see iBase_ErrorType) */
02140 );
02141 
02142 /***************************************************************************/ /**
02143                                                                                * \ingroup  Tags
02144                                                                                * \brief  Get the
02145                                                                                *name for a given tag
02146                                                                                *handle
02147                                                                                *
02148                                                                                * Get the name for a
02149                                                                                *given tag handle
02150                                                                                ******************************************************************************/
02151 
02152 void iMesh_getTagName( iMesh_Instance instance,
02153                        /**< [in] iMesh instance handle */
02154                        const iBase_TagHandle tag_handle,
02155                        /**< [in] Tag handle being queried */
02156                        char* name,
02157                        /**< [in,out] Pointer to character string to store name returned from */
02158                        int* err,
02159                        /**< [out] Returned Error status (see iBase_ErrorType) */
02160                        int name_len
02161                        /**< [in] Length of character string input to function
02162                             (\ref strlen) */
02163 );
02164 
02165 /***************************************************************************/ /**
02166                                                                                * \ingroup  Tags
02167                                                                                * \brief  Get size of
02168                                                                                *a tag in units of
02169                                                                                *numbers of tag data
02170                                                                                *type
02171                                                                                *
02172                                                                                * Get size of a tag
02173                                                                                *in units of numbers
02174                                                                                *of tag data type
02175                                                                                ******************************************************************************/
02176 
02177 void iMesh_getTagSizeValues( iMesh_Instance instance,
02178                              /**< [in] iMesh instance handle */
02179                              const iBase_TagHandle tag_handle,
02180                              /**< [in] Handle of tag being queried */
02181                              int* tag_size,
02182                              /**< [out] Pointer to tag size returned from function */
02183                              int* err
02184                              /**< [out] Returned Error status (see iBase_ErrorType) */
02185 );
02186 
02187 /***************************************************************************/ /**
02188                                                                                * \ingroup  Tags
02189                                                                                * \brief  Get size of
02190                                                                                *a tag in units of
02191                                                                                *bytes
02192                                                                                *
02193                                                                                * Get size of a tag
02194                                                                                *in units of bytes
02195                                                                                ******************************************************************************/
02196 
02197 void iMesh_getTagSizeBytes( iMesh_Instance instance,
02198                             /**< [in] iMesh instance handle */
02199                             const iBase_TagHandle tag_handle,
02200                             /**< [in] Handle of tag being queried */
02201                             int* tag_size,
02202                             /**< [out] Pointer to tag size returned from function */
02203                             int* err
02204                             /**< [out] Returned Error status (see iBase_ErrorType) */
02205 );
02206 
02207 /***************************************************************************/ /**
02208                                                                                * \ingroup  Tags
02209                                                                                * \brief  Get a the
02210                                                                                *handle of an
02211                                                                                *existing tag with
02212                                                                                *the specified name
02213                                                                                *
02214                                                                                * Get a the handle of
02215                                                                                *an existing tag with
02216                                                                                *the specified name
02217                                                                                ******************************************************************************/
02218 
02219 void iMesh_getTagHandle( iMesh_Instance instance,
02220                          /**< [in] iMesh instance handle */
02221                          const char* tag_name,
02222                          /**< [in] Name of tag being queried */
02223                          iBase_TagHandle* tag_handle,
02224                          /**< [out] Pointer to tag handle returned from function */
02225                          int* err,
02226                          /**< [out] Returned Error status (see iBase_ErrorType) */
02227                          int tag_name_len
02228                          /**< [in] Length of tag name string (\ref strlen) */
02229 );
02230 
02231 /***************************************************************************/ /**
02232                                                                                * \ingroup  Tags
02233                                                                                * \brief  Get the
02234                                                                                *data type of the
02235                                                                                *specified tag handle
02236                                                                                *
02237                                                                                * Get the data type
02238                                                                                *of the specified tag
02239                                                                                *handle.  Tag type is
02240                                                                                *a value in the
02241                                                                                *iBase_TagType
02242                                                                                *enumeration.
02243                                                                                ******************************************************************************/
02244 
02245 void iMesh_getTagType( iMesh_Instance instance,
02246                        /**< [in] iMesh instance handle */
02247                        const iBase_TagHandle tag_handle,
02248                        /**< [in] Handle for the tag being queried */
02249                        int* tag_type,
02250                        /**< [out] Pointer to tag type returned from function */
02251                        int* err
02252                        /**< [out] Returned Error status (see iBase_ErrorType) */
02253 );
02254 
02255 /***************************************************************************/ /**
02256                                                                                * \ingroup TagsOnSets
02257                                                                                * \brief  Set a tag
02258                                                                                *value of arbitrary
02259                                                                                *type on an entity
02260                                                                                *set
02261                                                                                *
02262                                                                                * Set a tag value of
02263                                                                                *arbitrary type on an
02264                                                                                *entity set. The tag
02265                                                                                *data is passed as
02266                                                                                *void*.
02267                                                                                *tag_value_size
02268                                                                                *specifies the size
02269                                                                                *of the memory
02270                                                                                * pointed to by
02271                                                                                *tag_value in terms
02272                                                                                *of bytes.
02273                                                                                *Applications are
02274                                                                                *free to use this
02275                                                                                *function to set data
02276                                                                                *of any type, not
02277                                                                                *just iBase_BYTES.
02278                                                                                * However, in all
02279                                                                                *cases, the size
02280                                                                                *specified by
02281                                                                                *tag_value_size is
02282                                                                                * always in terms of
02283                                                                                *bytes.
02284                                                                                ******************************************************************************/
02285 
02286 void iMesh_setEntSetData( iMesh_Instance instance,
02287                           /**< [in] iMesh instance handle */
02288                           iBase_EntitySetHandle entity_set_handle,
02289                           /**< [in] Entity set on which tag is being set */
02290                           const iBase_TagHandle tag_handle,
02291                           /**< [in] Tag being set on an entity set */
02292                           const void* tag_value,
02293                           /**< [in] Pointer to tag data being set on entity set */
02294                           const int tag_value_size,
02295                           /**< [in] Size in bytes of tag data */
02296                           int* err
02297                           /**< [out] Returned Error status (see iBase_ErrorType) */
02298 );
02299 
02300 /***************************************************************************/ /**
02301                                                                                * \ingroup TagsOnSets
02302                                                                                * \brief  Set a tag
02303                                                                                *value of integer
02304                                                                                *type on an entity
02305                                                                                *set
02306                                                                                *
02307                                                                                * Set a tag value of
02308                                                                                *integer type on an
02309                                                                                *entity set.
02310                                                                                ******************************************************************************/
02311 
02312 void iMesh_setEntSetIntData( iMesh_Instance instance,
02313                              /**< [in] iMesh instance handle */
02314                              iBase_EntitySetHandle entity_set,
02315                              /**< [in] Entity set on which tag is being set */
02316                              const iBase_TagHandle tag_handle,
02317                              /**< [in] Tag being set on an entity set */
02318                              const int tag_value,
02319                              /**< [in] Tag value being set on entity set */
02320                              int* err
02321                              /**< [out] Returned Error status (see iBase_ErrorType) */
02322 );
02323 
02324 /***************************************************************************/ /**
02325                                                                                * \ingroup TagsOnSets
02326                                                                                * \brief  Set a tag
02327                                                                                *value of double type
02328                                                                                *on an entity set
02329                                                                                *
02330                                                                                * Set a tag value of
02331                                                                                *double type on an
02332                                                                                *entity set.
02333                                                                                ******************************************************************************/
02334 
02335 void iMesh_setEntSetDblData( iMesh_Instance instance,
02336                              /**< [in] iMesh instance handle */
02337                              iBase_EntitySetHandle entity_set,
02338                              /**< [in] Entity set on which tag is being set */
02339                              const iBase_TagHandle tag_handle,
02340                              /**< [in] Tag being set on an entity set */
02341                              const double tag_value,
02342                              /**< [in] Tag value being set on entity set */
02343                              int* err
02344                              /**< [out] Returned Error status (see iBase_ErrorType) */
02345 );
02346 
02347 /***************************************************************************/ /**
02348                                                                                * \ingroup TagsOnSets
02349                                                                                * \brief  Set a tag
02350                                                                                *value of entity
02351                                                                                *handle type on an
02352                                                                                *entity set
02353                                                                                *
02354                                                                                * Set a tag value of
02355                                                                                *entity handle type
02356                                                                                *on an entity set.
02357                                                                                ******************************************************************************/
02358 
02359 void iMesh_setEntSetEHData( iMesh_Instance instance,
02360                             /**< [in] iMesh instance handle */
02361                             iBase_EntitySetHandle entity_set,
02362                             /**< [in] Entity set on which tag is being set */
02363                             const iBase_TagHandle tag_handle,
02364                             /**< [in] Tag being set on an entity set */
02365                             const iBase_EntityHandle tag_value,
02366                             /**< [in] Tag value being set on entity set */
02367                             int* err
02368                             /**< [out] Returned Error status (see iBase_ErrorType) */
02369 );
02370 
02371 /***************************************************************************/ /**
02372                                                                                * \ingroup TagsOnSets
02373                                                                                * \brief  Set a tag
02374                                                                                *value of entity set
02375                                                                                *handle type on an
02376                                                                                *
02377                                                                                *         entity set
02378                                                                                * Set a tag value of
02379                                                                                *entity set handle
02380                                                                                *type on an entity
02381                                                                                *set.
02382                                                                                ******************************************************************************/
02383 
02384 void iMesh_setEntSetESHData( iMesh_Instance instance,
02385                              /**< [in] iMesh instance handle */
02386                              iBase_EntitySetHandle entity_set,
02387                              /**< [in] Entity set on which tag is being set */
02388                              const iBase_TagHandle tag_handle,
02389                              /**< [in] Tag being set on an entity set */
02390                              const iBase_EntitySetHandle tag_value,
02391                              /**< [in] Tag value being set on entity set */
02392                              int* err
02393                              /**< [out] Returned Error status (see iBase_ErrorType) */
02394 );
02395 
02396 /***************************************************************************/ /**
02397                                                                                * \ingroup TagsOnSets
02398                                                                                * \brief  Get the
02399                                                                                *value of a tag of
02400                                                                                *arbitrary type on an
02401                                                                                *entity set
02402                                                                                *
02403                                                                                * Get the value of a
02404                                                                                *tag of arbitrary
02405                                                                                *type on an entity
02406                                                                                *set.  Tag data is
02407                                                                                *returned back as
02408                                                                                *void*.
02409                                                                                *tag_value_size
02410                                                                                *specifies the size
02411                                                                                *of the memory
02412                                                                                *pointed to by
02413                                                                                *tag_value in terms
02414                                                                                *of bytes.
02415                                                                                *Applications may use
02416                                                                                *this function to get
02417                                                                                *data of any type,
02418                                                                                *not just
02419                                                                                *iBase_BYTES. However
02420                                                                                *because this
02421                                                                                *function supports
02422                                                                                *data of arbitrary
02423                                                                                *type, in all cases
02424                                                                                *the size specified
02425                                                                                *by tag_value_size is
02426                                                                                *always in terms of
02427                                                                                *bytes.
02428                                                                                ******************************************************************************/
02429 
02430 void iMesh_getEntSetData( iMesh_Instance instance,
02431                           /**< [in] iMesh instance handle */
02432                           const iBase_EntitySetHandle entity_set_handle,
02433                           /**< [in] Entity set on which tag is being set */
02434                           const iBase_TagHandle tag_handle,
02435                           /**< [in] Tag being set on an entity set */
02436                           void* tag_value,
02437                           /**< [in,out] Pointer to tag data array being queried
02438                                \ref trio) */
02439                           int* tag_value_allocated,
02440                           /**< [in,out] Pointer allocated size, in bytes, of tag_value array. */
02441                           int* tag_value_size,
02442                           /**< [out] Pointer to occupied size, in bytes, of tag_value array. */
02443                           int* err
02444                           /**< [out] Returned Error status (see iBase_ErrorType) */
02445 );
02446 
02447 /***************************************************************************/ /**
02448                                                                                * \ingroup TagsOnSets
02449                                                                                * \brief  Get the
02450                                                                                *value of a tag of
02451                                                                                *integer type on an
02452                                                                                *entity set
02453                                                                                *
02454                                                                                * Get the value of a
02455                                                                                *tag of integer type
02456                                                                                *on an entity set.
02457                                                                                ******************************************************************************/
02458 
02459 void iMesh_getEntSetIntData( iMesh_Instance instance,
02460                              /**< [in] iMesh instance handle */
02461                              const iBase_EntitySetHandle entity_set,
02462                              /**< [in] Entity set on which tag is being set */
02463                              const iBase_TagHandle tag_handle,
02464                              /**< [in] Tag being set on an entity set */
02465                              int* out_data,
02466                              /**< [out] Pointer to tag value returned from function */
02467                              int* err
02468                              /**< [out] Returned Error status (see iBase_ErrorType) */
02469 );
02470 
02471 /***************************************************************************/ /**
02472                                                                                * \ingroup TagsOnSets
02473                                                                                * \brief  Get the
02474                                                                                *value of a tag of
02475                                                                                *double type on an
02476                                                                                *entity set
02477                                                                                *
02478                                                                                * Get the value of a
02479                                                                                *tag of double type
02480                                                                                *on an entity set.
02481                                                                                ******************************************************************************/
02482 
02483 void iMesh_getEntSetDblData( iMesh_Instance instance,
02484                              /**< [in] iMesh instance handle */
02485                              const iBase_EntitySetHandle entity_set,
02486                              /**< [in] Entity set on which tag is being set */
02487                              const iBase_TagHandle tag_handle,
02488                              /**< [in] Tag being set on an entity set */
02489                              double* out_data,
02490                              /**< [out] Pointer to tag value returned from function */
02491                              int* err
02492                              /**< [out] Returned Error status (see iBase_ErrorType) */
02493 );
02494 
02495 /***************************************************************************/ /**
02496                                                                                * \ingroup TagsOnSets
02497                                                                                * \brief  Get the
02498                                                                                *value of a tag of
02499                                                                                *entity handle type
02500                                                                                *on an entity set
02501                                                                                *
02502                                                                                * Get the value of a
02503                                                                                *tag of entity handle
02504                                                                                *type on an entity
02505                                                                                *set.
02506                                                                                ******************************************************************************/
02507 
02508 void iMesh_getEntSetEHData( iMesh_Instance instance,
02509                             /**< [in] iMesh instance handle */
02510                             const iBase_EntitySetHandle entity_set,
02511                             /**< [in] Entity set on which tag is being set */
02512                             const iBase_TagHandle tag_handle,
02513                             /**< [in] Tag being set on an entity set */
02514                             iBase_EntityHandle* out_data,
02515                             /**< [out] Pointer to tag value returned from function */
02516                             int* err
02517                             /**< [out] Returned Error status (see iBase_ErrorType) */
02518 );
02519 
02520 /***************************************************************************/ /**
02521                                                                                * \ingroup TagsOnSets
02522                                                                                * \brief  Get the
02523                                                                                *value of a tag of
02524                                                                                *entity set handle
02525                                                                                *type on an
02526                                                                                *
02527                                                                                *         entity set
02528                                                                                * Get the value of a
02529                                                                                *tag of entity set
02530                                                                                *handle type on an
02531                                                                                *entity set.
02532                                                                                ******************************************************************************/
02533 
02534 void iMesh_getEntSetESHData( iMesh_Instance instance,
02535                              /**< [in] iMesh instance handle */
02536                              const iBase_EntitySetHandle entity_set,
02537                              /**< [in] Entity set on which tag is being set */
02538                              const iBase_TagHandle tag_handle,
02539                              /**< [in] Tag being set on an entity set */
02540                              iBase_EntitySetHandle* out_data,
02541                              /**< [out] Pointer to tag value returned from function */
02542                              int* err
02543                              /**< [out] Returned Error status (see iBase_ErrorType) */
02544 );
02545 
02546 /***************************************************************************/ /**
02547                                                                                * \ingroup  Tags
02548                                                                                * \brief  Get all the
02549                                                                                *tags associated with
02550                                                                                *a specified entity
02551                                                                                *set
02552                                                                                *
02553                                                                                * Get all the tags
02554                                                                                *associated with a
02555                                                                                *specified entity set
02556                                                                                ******************************************************************************/
02557 
02558 void iMesh_getAllEntSetTags( iMesh_Instance instance,
02559                              /**< [in] iMesh instance handle */
02560                              const iBase_EntitySetHandle entity_set_handle,
02561                              /**< [in] Entity being queried */
02562                              iBase_TagHandle** tag_handles,
02563                              /**< [in,out] Pointer to array of tag_handles returned from
02564                                   \ref trio) */
02565                              int* tag_handles_allocated,
02566                              /**< [in,out] Pointer to allocated size of tag_handles  */
02567                              int* tag_handles_size,
02568                              /**< [out] Pointer to occupied size of tag_handles array */
02569                              int* err
02570                              /**< [out] Returned Error status (see iBase_ErrorType) */
02571 );
02572 
02573 /***************************************************************************/ /**
02574                                                                                * \ingroup  Tags
02575                                                                                * \brief  Remove a
02576                                                                                *tag value from an
02577                                                                                *entity set
02578                                                                                *
02579                                                                                * Remove a tag value
02580                                                                                *from an entity set
02581                                                                                ******************************************************************************/
02582 
02583 void iMesh_rmvEntSetTag( iMesh_Instance instance,
02584                          /**< [in] iMesh instance handle */
02585                          iBase_EntitySetHandle entity_set_handle,
02586                          /**< [in] Entity set from which tag is being removed */
02587                          const iBase_TagHandle tag_handle,
02588                          /**< [in] Tag handle of tag being removed */
02589                          int* err
02590                          /**< [out] Returned Error status (see iBase_ErrorType) */
02591 );
02592 
02593 /***************************************************************************/ /**
02594                                                                                * \ingroup
02595                                                                                *VertexEntities
02596                                                                                * \brief  Set
02597                                                                                *coordinates for a
02598                                                                                *vertex
02599                                                                                *
02600                                                                                * Set coordinates for
02601                                                                                *a vertex.
02602                                                                                ******************************************************************************/
02603 
02604 void iMesh_setVtxCoord( iMesh_Instance instance,
02605                         /**< [in] iMesh instance handle */
02606                         iBase_EntityHandle vertex_handle,
02607                         /**< [in] vertex handle being set */
02608                         const double x,
02609                         /**< [in] x coordinate being set */
02610                         const double y,
02611                         /**< [in] y coordinate being set */
02612                         const double z,
02613                         /**< [in] z coordinate being set */
02614                         int* err
02615                         /**< [out] Returned Error status (see iBase_ErrorType) */
02616 );
02617 
02618 /***************************************************************************/ /**
02619                                                                                * \ingroup
02620                                                                                *VertexEntities
02621                                                                                * \brief  Create a
02622                                                                                *new vertex at
02623                                                                                *specified
02624                                                                                *coordinates
02625                                                                                *
02626                                                                                * Create a new vertex
02627                                                                                *at specified
02628                                                                                *coordinates.
02629                                                                                ******************************************************************************/
02630 
02631 void iMesh_createVtx( iMesh_Instance instance,
02632                       /**< [in] iMesh instance handle */
02633                       const double x,
02634                       /**< [in] x coordinate of new vertex */
02635                       const double y,
02636                       /**< [in] y coordinate of new vertex */
02637                       const double z,
02638                       /**< [in] z coordinate of new vertex */
02639                       iBase_EntityHandle* new_vertex_handle,
02640                       /**< [out] Pointer to new vertex handles returned from  */
02641                       int* err
02642                       /**< [out] Returned Error status (see iBase_ErrorType) */
02643 );
02644 
02645 /***************************************************************************/ /**
02646                                                                                * \ingroup  Entities
02647                                                                                * \brief  Create a
02648                                                                                *new entity with
02649                                                                                *specified
02650                                                                                *lower-order topology
02651                                                                                *
02652                                                                                * Create a new entity
02653                                                                                *with specified
02654                                                                                *lower-order
02655                                                                                *topology. Specified
02656                                                                                *new_entity_topology
02657                                                                                *must be value in
02658                                                                                *iMesh_EntityTopology
02659                                                                                * enumeration.  Value
02660                                                                                *returned as status
02661                                                                                *must be a value in
02662                                                                                *the
02663                                                                                * iBase_CreationStatus
02664                                                                                *enumeration.
02665                                                                                ******************************************************************************/
02666 
02667 void iMesh_createEnt( iMesh_Instance instance,
02668                       /**< [in] iMesh instance handle */
02669                       const int new_entity_topology,
02670                       /**< [in] Topology of created entity */
02671                       const iBase_EntityHandle* lower_order_entity_handles,
02672                       /**< [in] Array of lower order entity handles to be used to construct
02673                          new entity. */
02674                       const int lower_order_entity_handles_size,
02675                       /**< [in] Number of entities in lower_order_entity_handles array */
02676                       iBase_EntityHandle* new_entity_handle,
02677                       /**< [out] Pointer to new entity handle returned from  */
02678                       int* status,
02679                       /**< [out] Pointer to creation status returned from function
02680                          (see iBase_CreationStatus) */
02681                       int* err
02682                       /**< [out] Returned Error status (see iBase_ErrorType) */
02683 );
02684 
02685 /***************************************************************************/ /**
02686                                                                                * \ingroup  Entities
02687                                                                                * \brief  Delete
02688                                                                                *specified entity
02689                                                                                *
02690                                                                                * Delete specified
02691                                                                                *entity
02692                                                                                ******************************************************************************/
02693 
02694 void iMesh_deleteEnt( iMesh_Instance instance,
02695                       /**< [in] iMesh instance handle */
02696                       iBase_EntityHandle entity_handle,
02697                       /**< [in] Entity to be deleted */
02698                       int* err
02699                       /**< [out] Returned Error status (see iBase_ErrorType) */
02700 );
02701 
02702 /***************************************************************************/ /**
02703                                                                                * \ingroup  TagsOnArr
02704                                                                                * \brief  Get tag
02705                                                                                *values of arbitrary
02706                                                                                *type for an array of
02707                                                                                *entities
02708                                                                                *
02709                                                                                * Get tag values of
02710                                                                                *arbitrary type for
02711                                                                                *an array of
02712                                                                                *entities.  Tag data
02713                                                                                * is returned as
02714                                                                                *void*.
02715                                                                                *tag_values_size
02716                                                                                *specifies the size
02717                                                                                *of the memory
02718                                                                                *pointed to by
02719                                                                                *tag_values in terms
02720                                                                                *of bytes.
02721                                                                                *Applications may use
02722                                                                                *this function to get
02723                                                                                *data of any type,
02724                                                                                *not just
02725                                                                                *iBase_BYTES.
02726                                                                                * However, because
02727                                                                                *this function
02728                                                                                *supports data of
02729                                                                                *arbitrary type, in
02730                                                                                * all cases the size
02731                                                                                *specified by
02732                                                                                *tag_values_size
02733                                                                                *always in terms of
02734                                                                                * bytes.
02735                                                                                ******************************************************************************/
02736 
02737 void iMesh_getArrData( iMesh_Instance instance,
02738                        /**< [in] iMesh instance handle */
02739                        const iBase_EntityHandle* entity_handles,
02740                        /**< [in] Entity array on which tag is being set */
02741                        const int entity_handles_size,
02742                        /**< [in] Number of entities in array */
02743                        const iBase_TagHandle tag_handle,
02744                        /**< [in] Tag being set on an entity */
02745                        void* tag_values,
02746                        /**< [in,out] Pointer to tag data array being returned. Note that the
02747                           implicit INTERLEAVED storage order rule applies
02748                           (see iBase_StorageOrder) \ref trio) */
02749                        int* tag_values_allocated,
02750                        /**< [in,out] Pointer to allocated size of tag data array */
02751                        int* tag_values_size,
02752                        /**< [out] Pointer to occupied size in bytes of tag data */
02753                        int* err
02754                        /**< [out] Returned Error status (see iBase_ErrorType) */
02755 );
02756 
02757 /***************************************************************************/ /**
02758                                                                                * \ingroup  TagsOnArr
02759                                                                                * \brief  Get tag
02760                                                                                *values of integer
02761                                                                                *type for an array of
02762                                                                                *entities
02763                                                                                *
02764                                                                                * Get tag values of
02765                                                                                *integer type for an
02766                                                                                *array of entities.
02767                                                                                ******************************************************************************/
02768 
02769 void iMesh_getIntArrData( iMesh_Instance instance,
02770                           /**< [in] iMesh instance handle */
02771                           const iBase_EntityHandle* entity_handles,
02772                           /**< [in] Entity array on which tag is being set */
02773                           const int entity_handles_size,
02774                           /**< [in] Number of entities in array */
02775                           const iBase_TagHandle tag_handle,
02776                           /**< [in] Tag being set on an entity */
02777                           int** tag_values,
02778                           /**< [in,out] Pointer to tag data array being returned. Note that the
02779                              implicit INTERLEAVED storage order rule applies
02780                              (see iBase_StorageOrder) \ref trio) */
02781                           int* tag_values_allocated,
02782                           /**< [in,out] Pointer to allocated size of tag data array */
02783                           int* tag_values_size,
02784                           /**< [out] Pointer to occupied size of tag data array */
02785                           int* err
02786                           /**< [out] Returned Error status (see iBase_ErrorType) */
02787 );
02788 
02789 /***************************************************************************/ /**
02790                                                                                * \ingroup  TagsOnArr
02791                                                                                * \brief  Get tag
02792                                                                                *values of double
02793                                                                                *type for an array of
02794                                                                                *entities
02795                                                                                *
02796                                                                                * Get tag values of
02797                                                                                *double type for an
02798                                                                                *array of entities.
02799                                                                                ******************************************************************************/
02800 
02801 void iMesh_getDblArrData( iMesh_Instance instance,
02802                           /**< [in] iMesh instance handle */
02803                           const iBase_EntityHandle* entity_handles,
02804                           /**< [in] Entity array on which tag is being set */
02805                           const int entity_handles_size,
02806                           /**< [in] Number of entities in array */
02807                           const iBase_TagHandle tag_handle,
02808                           /**< [in] Tag being set on an entity */
02809                           double** tag_values,
02810                           /**< [in,out] Pointer to tag data array being returned. Note that the
02811                              implicit INTERLEAVED storage order rule applies
02812                              (see iBase_StorageOrder) \ref trio) */
02813                           int* tag_values_allocated,
02814                           /**< [in,out] Pointer to allocated size of tag data array */
02815                           int* tag_values_size,
02816                           /**< [out] Pointer to occupied size of tag data array */
02817                           int* err
02818                           /**< [out] Returned Error status (see iBase_ErrorType) */
02819 );
02820 
02821 /***************************************************************************/ /**
02822                                                                                * \ingroup  TagsOnArr
02823                                                                                * \brief  Get tag
02824                                                                                *values of entity
02825                                                                                *handle type for an
02826                                                                                *array of entities
02827                                                                                *
02828                                                                                * Get tag values of
02829                                                                                *entity handle type
02830                                                                                *for an array of
02831                                                                                *entities.
02832                                                                                ******************************************************************************/
02833 
02834 void iMesh_getEHArrData( iMesh_Instance instance,
02835                          /**< [in] iMesh instance handle */
02836                          const iBase_EntityHandle* entity_handles,
02837                          /**< [in] Entity array on which tag is being set */
02838                          const int entity_handles_size,
02839                          /**< [in] Number of entities in array */
02840                          const iBase_TagHandle tag_handle,
02841                          /**< [in] Tag being set on an entity */
02842                          iBase_EntityHandle** tag_value,
02843                          /**< [in,out] Pointer to tag data array being returned. Note that the
02844                             implicit INTERLEAVED storage order rule applies
02845                             (see iBase_StorageOrder) \ref trio) */
02846                          int* tag_value_allocated,
02847                          /**< [in,out] Pointer to allocated size of tag data array */
02848                          int* tag_value_size,
02849                          /**< [out] Pointer to occupied size of tag data array */
02850                          int* err
02851                          /**< [out] Returned Error status (see iBase_ErrorType) */
02852 );
02853 
02854 /***************************************************************************/ /**
02855                                                                                * \ingroup  TagsOnArr
02856                                                                                * \brief  Get tag
02857                                                                                *values of entity set
02858                                                                                *handle type for an
02859                                                                                *array of
02860                                                                                *
02861                                                                                *         entities
02862                                                                                * Get tag values of
02863                                                                                *entity set handle
02864                                                                                *type for an array of
02865                                                                                *entities.
02866                                                                                ******************************************************************************/
02867 
02868 void iMesh_getESHArrData( iMesh_Instance instance,
02869                           /**< [in] iMesh instance handle */
02870                           const iBase_EntityHandle* entity_handles,
02871                           /**< [in] Entity array on which tag is being set */
02872                           const int entity_handles_size,
02873                           /**< [in] Number of entities in array */
02874                           const iBase_TagHandle tag_handle,
02875                           /**< [in] Tag being set on an entity */
02876                           iBase_EntitySetHandle** tag_value,
02877                           /**< [in,out] Pointer to tag data array being returned. Note that the
02878                              implicit INTERLEAVED storage order rule applies
02879                              (see iBase_StorageOrder) \ref trio) */
02880                           int* tag_value_allocated,
02881                           /**< [in,out] Pointer to allocated size of tag data array */
02882                           int* tag_value_size,
02883                           /**< [out] Pointer to occupied size of tag data array */
02884                           int* err
02885                           /**< [out] Returned Error status (see iBase_ErrorType) */
02886 );
02887 
02888 /***************************************************************************/ /**
02889                                                                                * \ingroup  TagsOnArr
02890                                                                                * \brief  Set tag
02891                                                                                *values of arbitrary
02892                                                                                *type on an array of
02893                                                                                *entities
02894                                                                                *
02895                                                                                * Set tag values of
02896                                                                                *arbitrary type on an
02897                                                                                *array of entities.
02898                                                                                *Tag data is passed
02899                                                                                *as void*.
02900                                                                                *tag_values_size
02901                                                                                *specifies the size
02902                                                                                *of the memory
02903                                                                                *pointed to by
02904                                                                                *tag_values in terms
02905                                                                                *of bytes.
02906                                                                                *Applications may use
02907                                                                                *this function to set
02908                                                                                *data of any type,
02909                                                                                *not just
02910                                                                                *iBase_BYTES.
02911                                                                                * However, because
02912                                                                                *this function
02913                                                                                *supports data of
02914                                                                                *arbitrary type, in
02915                                                                                *all cases the size
02916                                                                                *specified by
02917                                                                                *tag_values_size is
02918                                                                                *always in terms of
02919                                                                                * bytes.
02920                                                                                ******************************************************************************/
02921 
02922 void iMesh_setArrData( iMesh_Instance instance,
02923                        /**< [in] iMesh instance handle */
02924                        const iBase_EntityHandle* entity_handles,
02925                        /**< [in] Entity array on which tag is being set */
02926                        const int entity_handles_size,
02927                        /**< [in] Number of entities in array */
02928                        const iBase_TagHandle tag_handle,
02929                        /**< [in] Tag being set on an entity */
02930                        const void* tag_values,
02931                        /**< [in] Pointer to tag data being set on entity. Note that the
02932                           implicit INTERLEAVED storage order rule applies
02933                           (see iBase_StorageOrder) */
02934                        const int tag_values_size,
02935                        /**< [in] Size in bytes of tag data */
02936                        int* err
02937                        /**< [out] Returned Error status (see iBase_ErrorType) */
02938 );
02939 
02940 /***************************************************************************/ /**
02941                                                                                * \ingroup  TagsOnArr
02942                                                                                * \brief  Set tag
02943                                                                                *values of integer
02944                                                                                *type on an array of
02945                                                                                *entities
02946                                                                                *
02947                                                                                * Set tag values of
02948                                                                                *integer type on an
02949                                                                                *array of entities.
02950                                                                                ******************************************************************************/
02951 
02952 void iMesh_setIntArrData( iMesh_Instance instance,
02953                           /**< [in] iMesh instance handle */
02954                           const iBase_EntityHandle* entity_handles,
02955                           /**< [in] Entity array on which tag is being set */
02956                           const int entity_handles_size,
02957                           /**< [in] Number of entities in array */
02958                           const iBase_TagHandle tag_handle,
02959                           /**< [in] Tag being set on an entity */
02960                           const int* tag_values,
02961                           /**< [in] Pointer to tag data being set on entities. Note that the
02962                                implicit INTERLEAVED storage order rule applies
02963                                (see iBase_StorageOrder) */
02964                           const int tag_values_size,
02965                           /**< [in] Size in total number of integers of tag data */
02966                           int* err
02967                           /**< [out] Returned Error status (see iBase_ErrorType) */
02968 );
02969 
02970 /***************************************************************************/ /**
02971                                                                                * \ingroup  TagsOnArr
02972                                                                                * \brief  Set tag
02973                                                                                *values of double
02974                                                                                *type on an array of
02975                                                                                *entities
02976                                                                                *
02977                                                                                * Set tag values of
02978                                                                                *double type on an
02979                                                                                *array of entities.
02980                                                                                ******************************************************************************/
02981 
02982 void iMesh_setDblArrData( iMesh_Instance instance,
02983                           /**< [in] iMesh instance handle */
02984                           const iBase_EntityHandle* entity_handles,
02985                           /**< [in] Entity array on which tag is being set */
02986                           const int entity_handles_size,
02987                           /**< [in] Number of entities in array */
02988                           const iBase_TagHandle tag_handle,
02989                           /**< [in] Tag being set on an entity */
02990                           const double* tag_values,
02991                           /**< [in] Pointer to tag data being set on entities. Note that the
02992                                implicit INTERLEAVED storage order rule applies
02993                                (see iBase_StorageOrder) */
02994                           const int tag_values_size,
02995                           /**< [in] Size in total number of doubles of tag data */
02996                           int* err
02997                           /**< [out] Returned Error status (see iBase_ErrorType) */
02998 );
02999 
03000 /***************************************************************************/ /**
03001                                                                                * \ingroup  TagsOnArr
03002                                                                                * \brief  Set tag
03003                                                                                *values of entity
03004                                                                                *handle type on an
03005                                                                                *array of entities
03006                                                                                *
03007                                                                                * Set tag values of
03008                                                                                *entity handle type
03009                                                                                *on an array of
03010                                                                                *entities.
03011                                                                                ******************************************************************************/
03012 
03013 void iMesh_setEHArrData( iMesh_Instance instance,
03014                          /**< [in] iMesh instance handle */
03015                          const iBase_EntityHandle* entity_handles,
03016                          /**< [in] Entity array on which tag is being set */
03017                          const int entity_handles_size,
03018                          /**< [in] Number of entities in array */
03019                          const iBase_TagHandle tag_handle,
03020                          /**< [in] Tag being set on an entity */
03021                          const iBase_EntityHandle* tag_values,
03022                          /**< [in] Pointer to tag data being set on entities. Note that the
03023                             implicit INTERLEAVED storage order rule applies
03024                             (see iBase_StorageOrder) */
03025                          const int tag_values_size,
03026                          /**< [in] Size in total number of entity handles of tag  */
03027                          int* err
03028                          /**< [out] Returned Error status (see iBase_ErrorType) */
03029 );
03030 
03031 /***************************************************************************/ /**
03032                                                                                * \ingroup  TagsOnArr
03033                                                                                * \brief  Set tag
03034                                                                                *values of entity set
03035                                                                                *handle type on an
03036                                                                                *array of
03037                                                                                *
03038                                                                                *         entities
03039                                                                                * Set tag values of
03040                                                                                *entity set handle
03041                                                                                *type on an array of
03042                                                                                *entities.
03043                                                                                ******************************************************************************/
03044 
03045 void iMesh_setESHArrData( iMesh_Instance instance,
03046                           /**< [in] iMesh instance handle */
03047                           const iBase_EntityHandle* entity_handles,
03048                           /**< [in] Entity array on which tag is being set */
03049                           const int entity_handles_size,
03050                           /**< [in] Number of entities in array */
03051                           const iBase_TagHandle tag_handle,
03052                           /**< [in] Tag being set on an entity */
03053                           const iBase_EntitySetHandle* tag_values,
03054                           /**< [in] Pointer to tag data being set on entities. Note that the
03055                              implicit INTERLEAVED storage order rule applies
03056                              (see iBase_StorageOrder) */
03057                           const int tag_values_size,
03058                           /**< [in] Size in total number of entity handles of tag  */
03059                           int* err
03060                           /**< [out] Returned Error status (see iBase_ErrorType) */
03061 );
03062 
03063 /***************************************************************************/ /**
03064                                                                                * \ingroup  Tags
03065                                                                                * \brief  Remove a
03066                                                                                *tag value from an
03067                                                                                *array of entities
03068                                                                                *
03069                                                                                * Remove a tag value
03070                                                                                *from an array of
03071                                                                                *entities
03072                                                                                ******************************************************************************/
03073 
03074 void iMesh_rmvArrTag( iMesh_Instance instance,
03075                       /**< [in] iMesh instance handle */
03076                       const iBase_EntityHandle* entity_handles,
03077                       /**< [in] Entity from which tag is being removed */
03078                       const int entity_handles_size,
03079                       /**< [in] Number of entities in entity array */
03080                       const iBase_TagHandle tag_handle,
03081                       /**< [in] Tag handle of tag being removed */
03082                       int* err
03083                       /**< [out] Returned Error status (see iBase_ErrorType) */
03084 );
03085 
03086 /***************************************************************************/ /**
03087                                                                                * \ingroup TagsOnEnts
03088                                                                                * \brief  Get the
03089                                                                                *value of a tag of
03090                                                                                *arbitrary type on an
03091                                                                                *entity
03092                                                                                *
03093                                                                                * Get the value of a
03094                                                                                *tag of arbitrary
03095                                                                                *type on an entity.
03096                                                                                *Tag data is passed
03097                                                                                *back as void*.
03098                                                                                *tag_value_size
03099                                                                                *specifies the size
03100                                                                                *of the memory
03101                                                                                *pointed to by
03102                                                                                *tag_value in terms
03103                                                                                *of bytes.
03104                                                                                *Applications may use
03105                                                                                *this function to get
03106                                                                                *data of any type,
03107                                                                                *not just
03108                                                                                *iBase_BYTES.
03109                                                                                * However, because
03110                                                                                *this function
03111                                                                                *supports arbitrary
03112                                                                                *type, in all cases
03113                                                                                *the size specified
03114                                                                                *by tag_value_size is
03115                                                                                *always in terms of
03116                                                                                * bytes.
03117                                                                                ******************************************************************************/
03118 
03119 void iMesh_getData( iMesh_Instance instance,
03120                     /**< [in] iMesh instance handle */
03121                     const iBase_EntityHandle entity_handle,
03122                     /**< [in] Entity on which tag is being set */
03123                     const iBase_TagHandle tag_handle,
03124                     /**< [in] Tag being set on an entity */
03125                     void* tag_value,
03126                     /**< [in,out] Pointer to tag data array being queried
03127                          \ref trio) */
03128                     int* tag_value_allocated,
03129                     /**< [in,out] Pointer to tag data array allocated size */
03130                     int* tag_value_size,
03131                     /**< [out] Pointer to occupied size in bytes of tag data */
03132                     int* err
03133                     /**< [out] Returned Error status (see iBase_ErrorType) */
03134 );
03135 
03136 /***************************************************************************/ /**
03137                                                                                * \ingroup TagsOnEnts
03138                                                                                * \brief  Get the
03139                                                                                *value of a tag of
03140                                                                                *integer type on an
03141                                                                                *entity
03142                                                                                *
03143                                                                                * Get the value of a
03144                                                                                *tag of integer type
03145                                                                                *on an entity.
03146                                                                                ******************************************************************************/
03147 
03148 void iMesh_getIntData( iMesh_Instance instance,
03149                        /**< [in] iMesh instance handle */
03150                        const iBase_EntityHandle entity_handle,
03151                        /**< [in] Entity on which tag is being set */
03152                        const iBase_TagHandle tag_handle,
03153                        /**< [in] Tag being set on an entity */
03154                        int* out_data,
03155                        /**< [out] Pointer to tag value returned from function */
03156                        int* err
03157                        /**< [out] Returned Error status (see iBase_ErrorType) */
03158 );
03159 
03160 /***************************************************************************/ /**
03161                                                                                * \ingroup TagsOnEnts
03162                                                                                * \brief  Get the
03163                                                                                *value of a tag of
03164                                                                                *double type on an
03165                                                                                *entity
03166                                                                                *
03167                                                                                * Get the value of a
03168                                                                                *tag of double type
03169                                                                                *on an entity.
03170                                                                                ******************************************************************************/
03171 
03172 void iMesh_getDblData( iMesh_Instance instance,
03173                        /**< [in] iMesh instance handle */
03174                        const iBase_EntityHandle entity_handle,
03175                        /**< [in] Entity on which tag is being set */
03176                        const iBase_TagHandle tag_handle,
03177                        /**< [in] Tag being set on an entity */
03178                        double* out_data,
03179                        /**< [out] Pointer to tag value returned from function */
03180                        int* err
03181                        /**< [out] Returned Error status (see iBase_ErrorType) */
03182 );
03183 
03184 /***************************************************************************/ /**
03185                                                                                * \ingroup TagsOnEnts
03186                                                                                * \brief  Get the
03187                                                                                *value of a tag of
03188                                                                                *entity handle type
03189                                                                                *on an entity
03190                                                                                *
03191                                                                                * Get the value of a
03192                                                                                *tag of entity handle
03193                                                                                *type on an entity.
03194                                                                                ******************************************************************************/
03195 
03196 void iMesh_getEHData( iMesh_Instance instance,
03197                       /**< [in] iMesh instance handle */
03198                       const iBase_EntityHandle entity_handle,
03199                       /**< [in] Entity on which tag is being set */
03200                       const iBase_TagHandle tag_handle,
03201                       /**< [in] Tag being set on an entity */
03202                       iBase_EntityHandle* out_data,
03203                       /**< [out] Pointer to tag value returned from function */
03204                       int* err
03205                       /**< [out] Returned Error status (see iBase_ErrorType) */
03206 );
03207 
03208 /***************************************************************************/ /**
03209                                                                                * \ingroup TagsOnEnts
03210                                                                                * \brief  Get the
03211                                                                                *value of a tag of
03212                                                                                *entity set handle
03213                                                                                *type on an
03214                                                                                *
03215                                                                                *         entity
03216                                                                                * Get the value of a
03217                                                                                *tag of entity set
03218                                                                                *handle type on an
03219                                                                                *entity.
03220                                                                                ******************************************************************************/
03221 
03222 void iMesh_getESHData( iMesh_Instance instance,
03223                        /**< [in] iMesh instance handle */
03224                        const iBase_EntityHandle entity_handle,
03225                        /**< [in] Entity on which tag is being set */
03226                        const iBase_TagHandle tag_handle,
03227                        /**< [in] Tag being set on an entity */
03228                        iBase_EntitySetHandle* out_data,
03229                        /**< [out] Pointer to tag value returned from function */
03230                        int* err
03231                        /**< [out] Returned Error status (see iBase_ErrorType) */
03232 );
03233 
03234 /***************************************************************************/ /**
03235                                                                                * \ingroup TagsOnEnts
03236                                                                                * \brief  Set a tag
03237                                                                                *value of arbitrary
03238                                                                                *type on an entity
03239                                                                                *
03240                                                                                * Set a tag value of
03241                                                                                *arbitrary type on an
03242                                                                                *entity.  Tag data is
03243                                                                                *passed as void*.
03244                                                                                *tag_value_size
03245                                                                                *specifies the size
03246                                                                                *of the memory
03247                                                                                *pointed to by
03248                                                                                *tag_value in terms
03249                                                                                *of bytes.
03250                                                                                *Applications may use
03251                                                                                *this function to set
03252                                                                                *data of any type,
03253                                                                                *not just
03254                                                                                *iBase_BYTES.
03255                                                                                * However, because
03256                                                                                *this function
03257                                                                                *supports data of
03258                                                                                *arbitrary type, in
03259                                                                                * all cases the size
03260                                                                                *specified by
03261                                                                                *tag_value_size is
03262                                                                                *always in terms of
03263                                                                                *bytes.
03264                                                                                ******************************************************************************/
03265 
03266 void iMesh_setData( iMesh_Instance instance,
03267                     /**< [in] iMesh instance handle */
03268                     iBase_EntityHandle entity_handle,
03269                     /**< [in] Entity on which tag is being set */
03270                     const iBase_TagHandle tag_handle,
03271                     /**< [in] Tag being set on an entity */
03272                     const void* tag_value,
03273                     /**< [in] Pointer to tag data being set on entity */
03274                     const int tag_value_size,
03275                     /**< [in] Size in bytes of tag data */
03276                     int* err
03277                     /**< [out] Returned Error status (see iBase_ErrorType) */
03278 );
03279 
03280 /***************************************************************************/ /**
03281                                                                                * \ingroup TagsOnEnts
03282                                                                                * \brief  Set a tag
03283                                                                                *value of integer
03284                                                                                *type on an entity
03285                                                                                *
03286                                                                                * Set a tag value of
03287                                                                                *integer type on an
03288                                                                                *entity.
03289                                                                                ******************************************************************************/
03290 
03291 void iMesh_setIntData( iMesh_Instance instance,
03292                        /**< [in] iMesh instance handle */
03293                        iBase_EntityHandle entity_handle,
03294                        /**< [in] Entity on which tag is being set */
03295                        const iBase_TagHandle tag_handle,
03296                        /**< [in] Tag being set on an entity */
03297                        const int tag_value,
03298                        /**< [in] Tag value being set on entity */
03299                        int* err
03300                        /**< [out] Returned Error status (see iBase_ErrorType) */
03301 );
03302 
03303 /***************************************************************************/ /**
03304                                                                                * \ingroup TagsOnEnts
03305                                                                                * \brief  Set a tag
03306                                                                                *value of double type
03307                                                                                *on an entity
03308                                                                                *
03309                                                                                * Set a tag value of
03310                                                                                *double type on an
03311                                                                                *entity.
03312                                                                                ******************************************************************************/
03313 
03314 void iMesh_setDblData( iMesh_Instance instance,
03315                        /**< [in] iMesh instance handle */
03316                        iBase_EntityHandle entity_handle,
03317                        /**< [in] Entity on which tag is being set */
03318                        const iBase_TagHandle tag_handle,
03319                        /**< [in] Tag being set on an entity */
03320                        const double tag_value,
03321                        /**< [in] Tag value being set on entity */
03322                        int* err
03323                        /**< [out] Returned Error status (see iBase_ErrorType) */
03324 );
03325 
03326 /***************************************************************************/ /**
03327                                                                                * \ingroup TagsOnEnts
03328                                                                                * \brief  Set a tag
03329                                                                                *value of entity
03330                                                                                *handle type on an
03331                                                                                *entity
03332                                                                                *
03333                                                                                * Set a tag value of
03334                                                                                *entity handle type
03335                                                                                *on an entity.
03336                                                                                ******************************************************************************/
03337 
03338 void iMesh_setEHData( iMesh_Instance instance,
03339                       /**< [in] iMesh instance handle */
03340                       iBase_EntityHandle entity_handle,
03341                       /**< [in] Entity on which tag is being set */
03342                       const iBase_TagHandle tag_handle,
03343                       /**< [in] Tag being set on an entity */
03344                       const iBase_EntityHandle tag_value,
03345                       /**< [in] Tag value being set on entity */
03346                       int* err
03347                       /**< [out] Returned Error status (see iBase_ErrorType) */
03348 );
03349 
03350 /***************************************************************************/ /**
03351                                                                                * \ingroup TagsOnEnts
03352                                                                                * \brief  Set a tag
03353                                                                                *value of entity set
03354                                                                                *handle type on an
03355                                                                                *entity
03356                                                                                *
03357                                                                                * Set a tag value of
03358                                                                                *entity set handle
03359                                                                                *type on an entity.
03360                                                                                ******************************************************************************/
03361 
03362 void iMesh_setESHData( iMesh_Instance instance,
03363                        /**< [in] iMesh instance handle */
03364                        iBase_EntityHandle entity_handle,
03365                        /**< [in] Entity on which tag is being set */
03366                        const iBase_TagHandle tag_handle,
03367                        /**< [in] Tag being set on an entity */
03368                        const iBase_EntitySetHandle tag_value,
03369                        /**< [in] Tag value being set on entity */
03370                        int* err
03371                        /**< [out] Returned Error status (see iBase_ErrorType) */
03372 );
03373 
03374 /***************************************************************************/ /**
03375                                                                                * \ingroup  Tags
03376                                                                                * \brief  Get all the
03377                                                                                *tags associated with
03378                                                                                *a specified entity
03379                                                                                *handle
03380                                                                                *
03381                                                                                * Get all the tags
03382                                                                                *associated with a
03383                                                                                *specified entity
03384                                                                                *handle
03385                                                                                ******************************************************************************/
03386 
03387 void iMesh_getAllTags( iMesh_Instance instance,
03388                        /**< [in] iMesh instance handle */
03389                        const iBase_EntityHandle entity_handle,
03390                        /**< [in] Entity being queried */
03391                        iBase_TagHandle** tag_handles,
03392                        /**< [in,out] Pointer to array of tag_handles returned from
03393                             \ref trio) */
03394                        int* tag_handles_allocated,
03395                        /**< [in,out] Pointer to allocated size of tag_handles  */
03396                        int* tag_handles_size,
03397                        /**< [out] Pointer to occupied size of tag_handles array */
03398                        int* err
03399                        /**< [out] Returned Error status (see iBase_ErrorType) */
03400 );
03401 
03402 /***************************************************************************/ /**
03403                                                                                * \ingroup  Tags
03404                                                                                * \brief  Remove a
03405                                                                                *tag value from an
03406                                                                                *entity
03407                                                                                *
03408                                                                                * Remove a tag value
03409                                                                                *from an entity
03410                                                                                ******************************************************************************/
03411 
03412 void iMesh_rmvTag( iMesh_Instance instance,
03413                    /**< [in] iMesh instance handle */
03414                    iBase_EntityHandle entity_handle,
03415                    /**< [in] Entity from which tag is being removed */
03416                    const iBase_TagHandle tag_handle,
03417                    /**< [in] Tag handle of tag being removed */
03418                    int* err
03419                    /**< [out] Returned Error status (see iBase_ErrorType) */
03420 );
03421 
03422 /***************************************************************************/ /**
03423                                                                                * \ingroup
03424                                                                                *EntityIterators
03425                                                                                * \brief  Initialize
03426                                                                                *an iterator over
03427                                                                                *specified entity
03428                                                                                *type, topology, and
03429                                                                                *size
03430                                                                                *
03431                                                                                * Initialize an
03432                                                                                *iterator over
03433                                                                                *specified entity
03434                                                                                *type, topology, and
03435                                                                                *size, for a
03436                                                                                *specified set or
03437                                                                                *instance.  Iterator
03438                                                                                *returned can be used
03439                                                                                *as input to
03440                                                                                *functions returning
03441                                                                                *the entity for the
03442                                                                                *iterator.  If all
03443                                                                                *entities of a
03444                                                                                *specified type
03445                                                                                *and/or topology are
03446                                                                                *to be iterated,
03447                                                                                *specify
03448                                                                                * iBase_ALL_TYPES or
03449                                                                                *iMesh_ALL_TOPOLOGIES,
03450                                                                                *respectively.
03451                                                                                *Specified type or
03452                                                                                *topology must be a
03453                                                                                *value in the
03454                                                                                *iBase_EntityType or
03455                                                                                * iMesh_EntityTopology
03456                                                                                *enumerations,
03457                                                                                *respectively.
03458                                                                                *
03459                                                                                * Note: This function
03460                                                                                *will fail and return
03461                                                                                *an error if the
03462                                                                                *caller passes a
03463                                                                                * combination of
03464                                                                                *entity_type and
03465                                                                                *entity_topology that
03466                                                                                *are not consistent.
03467                                                                                ******************************************************************************/
03468 
03469 void iMesh_initEntIter( iMesh_Instance instance,
03470                         /**< [in] iMesh instance handle */
03471                         const iBase_EntitySetHandle entity_set_handle,
03472                         /**< [in] Entity set being iterated */
03473                         const int requested_entity_type,
03474                         /**< [in] Type of entity to iterate */
03475                         const int requested_entity_topology,
03476                         /**< [in] Topology of entity to iterate */
03477                         const int resilient,
03478                         /**< [in] If zero, return a non-resilient iterator.
03479                                   Otherwise, a resilient iterator (\ref resilient) */
03480                         iBase_EntityIterator* entity_iterator,
03481                         /**< [out] Pointer to iterator returned from function */
03482                         int* err
03483                         /**< [out] Returned Error status (see iBase_ErrorType) */
03484 );
03485 
03486 /***************************************************************************/ /**
03487                                                                                * \ingroup
03488                                                                                *EntityIterators
03489                                                                                * \brief  Get entity
03490                                                                                *corresponding to an
03491                                                                                *iterator and
03492                                                                                *increment iterator
03493                                                                                *
03494                                                                                * Get the entity
03495                                                                                *corresponding to an
03496                                                                                *iterator (that is,
03497                                                                                *dereference the
03498                                                                                *iterator), and
03499                                                                                *increment the
03500                                                                                *iterator. The
03501                                                                                *dereferenced value
03502                                                                                * is returned in
03503                                                                                *'entity_handle'. If
03504                                                                                *the iterator is at
03505                                                                                *the end of the
03506                                                                                * iteration, the
03507                                                                                *dereferenced value
03508                                                                                *will be undefined
03509                                                                                *and 'has_data' will
03510                                                                                *have a value of
03511                                                                                *zero. Otherwise,
03512                                                                                *'has_data' will have
03513                                                                                *a non-zero value.
03514                                                                                ******************************************************************************/
03515 
03516 void iMesh_getNextEntIter( iMesh_Instance instance,
03517                            /**< [in] iMesh instance handle */
03518                            iBase_EntityIterator entity_iterator,
03519                            /**< [in] Iterator being queried */
03520                            iBase_EntityHandle* entity_handle,
03521                            /**< [out] Pointer to an entity handle corresponding to the current
03522                               value of iterator just prior to the call. */
03523                            int* has_data,
03524                            /**< [out] Pointer to a flag indicating if the value returned in
03525                               entity_handle is valid. A non-zero value indicates the value is
03526                               valid. A zero value indicates the value is NOT valid. */
03527                            int* err
03528                            /**< [out] Returned Error status (see iBase_ErrorType) */
03529 );
03530 
03531 /***************************************************************************/ /**
03532                                                                                * \ingroup
03533                                                                                *EntityIterators
03534                                                                                * \brief  Reset the
03535                                                                                *iterator
03536                                                                                *
03537                                                                                * Reset the iterator
03538                                                                                ******************************************************************************/
03539 
03540 void iMesh_resetEntIter( iMesh_Instance instance,
03541                          /**< [in] iMesh instance handle */
03542                          iBase_EntityIterator entity_iterator,
03543                          /**< [in] Iterator to reset */
03544                          int* err
03545                          /**< [out] Returned Error status (see iBase_ErrorType) */
03546 );
03547 
03548 /***************************************************************************/ /**
03549                                                                                * \ingroup
03550                                                                                *EntityIterators
03551                                                                                * \brief  Destroy the
03552                                                                                *specified iterator
03553                                                                                *
03554                                                                                * Destroy the
03555                                                                                *specified iterator
03556                                                                                ******************************************************************************/
03557 
03558 void iMesh_endEntIter( iMesh_Instance instance,
03559                        /**< [in] iMesh instance handle */
03560                        iBase_EntityIterator entity_iterator,
03561                        /**< [in] Iterator which gets destroyed */
03562                        int* err
03563                        /**< [out] Returned Error status (see iBase_ErrorType) */
03564 );
03565 
03566 /***************************************************************************/ /**
03567                                                                                * \ingroup  Entities
03568                                                                                * \brief  Get the
03569                                                                                *entity topology for
03570                                                                                *the specified entity
03571                                                                                *
03572                                                                                * Get the entity
03573                                                                                *topology for the
03574                                                                                *specified entity.
03575                                                                                *Topology returned is
03576                                                                                *a value in the
03577                                                                                *iMesh_EntityTopology
03578                                                                                *enumeration.
03579                                                                                ******************************************************************************/
03580 
03581 void iMesh_getEntTopo( iMesh_Instance instance,
03582                        /**< [in] iMesh instance handle */
03583                        const iBase_EntityHandle entity_handle,
03584                        /**< [in] Entity handle being queried */
03585                        int* out_topo,
03586                        /**< [out] Pointer to entity topology returned from function */
03587                        int* err
03588                        /**< [out] Returned Error status (see iBase_ErrorType) */
03589 );
03590 
03591 /***************************************************************************/ /**
03592                                                                                * \ingroup  Entities
03593                                                                                * \brief  Get the
03594                                                                                *entity type for the
03595                                                                                *specified entity
03596                                                                                *
03597                                                                                * Get the entity type
03598                                                                                *for the specified
03599                                                                                *entity.  Type
03600                                                                                *returned is a value
03601                                                                                * in the
03602                                                                                *iBase_EntityType
03603                                                                                *enumeration.
03604                                                                                ******************************************************************************/
03605 
03606 void iMesh_getEntType( iMesh_Instance instance,
03607                        /**< [in] iMesh instance handle */
03608                        const iBase_EntityHandle entity_handle,
03609                        /**< [in] Entity handle being queried */
03610                        int* out_type,
03611                        /**< [out] Pointer to entity type returned from function */
03612                        int* err
03613                        /**< [out] Returned Error status (see iBase_ErrorType) */
03614 );
03615 
03616 /***************************************************************************/ /**
03617                                                                                * \ingroup
03618                                                                                *VertexEntities
03619                                                                                * \brief  Get
03620                                                                                *coordinates of
03621                                                                                *specified vertex
03622                                                                                *
03623                                                                                * Get coordinates of
03624                                                                                *specified vertex.
03625                                                                                ******************************************************************************/
03626 
03627 void iMesh_getVtxCoord( iMesh_Instance instance,
03628                         /**< [in] iMesh instance handle */
03629                         const iBase_EntityHandle vertex_handle,
03630                         /**< [in] Mesh vertex being queried */
03631                         double* x,
03632                         /**< [out] Pointer to x coordinate returned from function */
03633                         double* y,
03634                         /**< [out] Pointer to y coordinate returned from function */
03635                         double* z,
03636                         /**< [out] Pointer to z coordinate returned from function */
03637                         int* err
03638                         /**< [out] Returned Error status (see iBase_ErrorType) */
03639 );
03640 
03641 /***************************************************************************/ /**
03642                                                                                * \ingroup
03643                                                                                *Adjacencies \brief
03644                                                                                *Get entities of
03645                                                                                *specified type
03646                                                                                *adjacent to an
03647                                                                                *entity
03648                                                                                *
03649                                                                                * Get entities of
03650                                                                                *specified type
03651                                                                                *adjacent to an
03652                                                                                *entity.  Specified
03653                                                                                *type must be value
03654                                                                                *in the
03655                                                                                *iBase_EntityType
03656                                                                                *enumeration.
03657                                                                                *
03658                                                                                * Note 1: Because
03659                                                                                *'adjacent' as
03660                                                                                *defined by the iMesh
03661                                                                                *data model refers to
03662                                                                                *those entities that
03663                                                                                *bound another, the
03664                                                                                *entity being queried
03665                                                                                *         here (in
03666                                                                                *entity_handle arg)
03667                                                                                *is NEVER ALSO
03668                                                                                *returned in
03669                                                                                *         adj_entity_handles
03670                                                                                *even if the
03671                                                                                *entity_type_requested
03672                                                                                *         matches the
03673                                                                                *entity type in
03674                                                                                *entity_handle.
03675                                                                                ******************************************************************************/
03676 
03677 void iMesh_getEntAdj( iMesh_Instance instance,
03678                       /**< [in] iMesh instance handle */
03679                       const iBase_EntityHandle entity_handle,
03680                       /**< [in] Entity handle being queried */
03681                       const int entity_type_requested,
03682                       /**< [in] Type of adjacent entities requested */
03683                       iBase_EntityHandle** adj_entity_handles,
03684                       /**< [in,out] Pointer to array of adjacent entities \ref trio) */
03685                       int* adj_entity_handles_allocated,
03686                       /**< [in,out] Pointer to allocated size of adj_entity_handles */
03687                       int* adj_entity_handles_size,
03688                       /**< [out] Pointer to occupied size of adj_entity_handles */
03689                       int* err
03690                       /**< [out] Returned Error status (see iBase_ErrorType) */
03691 );
03692 
03693 /***************************************************************************/ /**
03694                                                                                * \ingroup
03695                                                                                *Adjacencies \brief
03696                                                                                *Get "2nd order"
03697                                                                                *adjacencies to an
03698                                                                                *entity
03699                                                                                *
03700                                                                                * Get "2nd order"
03701                                                                                *adjacencies to an
03702                                                                                *entity, that is,
03703                                                                                *from an entity,
03704                                                                                *through other
03705                                                                                *entities of a
03706                                                                                *specified "bridge"
03707                                                                                *dimension, to other
03708                                                                                *entities of another
03709                                                                                *specified "to"
03710                                                                                *dimension. Note 1:
03711                                                                                *If the "bridge"
03712                                                                                *dimension is the
03713                                                                                *same as the "to"
03714                                                                                *dimension or the
03715                                                                                *dimension of the
03716                                                                                *input entity, the
03717                                                                                *output will be empty
03718                                                                                *    (and an error
03719                                                                                *code of
03720                                                                                *iBase_INVALID_ARGUMENT
03721                                                                                *returned).  This is
03722                                                                                *    consistent with
03723                                                                                *the definition of
03724                                                                                *adjacencies and the
03725                                                                                *behavior of iMesh
03726                                                                                *first adjacency
03727                                                                                *calls. Note 2: An
03728                                                                                *entity will never be
03729                                                                                *returned as a second
03730                                                                                *adjacency of itself,
03731                                                                                *on the grounds that
03732                                                                                *this is the most
03733                                                                                *likely expectation
03734                                                                                *of applications, and
03735                                                                                *that it is easier
03736                                                                                *for an application
03737                                                                                *to add the original
03738                                                                                *entity to the
03739                                                                                *returned data than
03740                                                                                *to find and remove
03741                                                                                *it.
03742                                                                                ******************************************************************************/
03743 
03744 void iMesh_getEnt2ndAdj( iMesh_Instance instance,
03745                          /**< [in] iMesh instance handle */
03746                          iBase_EntityHandle entity_handle,
03747                          /**< [in] Entity from which adjacencies are requested */
03748                          int bridge_entity_type,
03749                          /**< [in]  Type of bridge entity for 2nd order adjacencies */
03750                          int requested_entity_type,
03751                          /**< [in] Type of adjacent entities returned */
03752                          iBase_EntityHandle** adjacent_entities,
03753                          /**< [in,out] Adjacent entities \ref trio) */
03754                          int* adjacent_entities_allocated,
03755                          /**< [in,out] Allocated size of returned array */
03756                          int* adjacent_entities_size,
03757                          /**< [out] Occupied size of returned array */
03758                          int* err
03759                          /**< [out] Returned Error status (see iBase_ErrorType) */
03760 );
03761 
03762 /***************************************************************************/ /**
03763                                                                                * \ingroup
03764                                                                                *EntitySetOperators
03765                                                                                * \brief  Subtract
03766                                                                                *contents of one
03767                                                                                *entity set from
03768                                                                                *another
03769                                                                                *
03770                                                                                * Subtract contents
03771                                                                                *of one entity set
03772                                                                                *from another
03773                                                                                ******************************************************************************/
03774 
03775 void iMesh_subtract( iMesh_Instance instance,
03776                      /**< [in] iMesh instance handle */
03777                      const iBase_EntitySetHandle entity_set_1,
03778                      /**< [in] Entity set from which other set is being subtracted */
03779                      const iBase_EntitySetHandle entity_set_2,
03780                      /**< [in] Entity set being subtracted from other set */
03781                      iBase_EntitySetHandle* result_entity_set,
03782                      /**< [out] Pointer to entity set returned from function */
03783                      int* err
03784                      /**< [out] Returned Error status (see iBase_ErrorType) */
03785 );
03786 
03787 /***************************************************************************/ /**
03788                                                                                * \ingroup
03789                                                                                *EntitySetOperators
03790                                                                                * \brief  Intersect
03791                                                                                *contents of one
03792                                                                                *entity set with
03793                                                                                *another
03794                                                                                *
03795                                                                                * Intersect contents
03796                                                                                *of one entity set
03797                                                                                *with another
03798                                                                                ******************************************************************************/
03799 
03800 void iMesh_intersect( iMesh_Instance instance,
03801                       /**< [in] iMesh instance handle */
03802                       const iBase_EntitySetHandle entity_set_1,
03803                       /**< [in] Entity set being intersected with another */
03804                       const iBase_EntitySetHandle entity_set_2,
03805                       /**< [in] Entity set being intersected with another */
03806                       iBase_EntitySetHandle* result_entity_set,
03807                       /**< [out] Pointer to entity set returned from function */
03808                       int* err
03809                       /**< [out] Returned Error status (see iBase_ErrorType) */
03810 );
03811 
03812 /***************************************************************************/ /**
03813                                                                                * \ingroup
03814                                                                                *EntitySetOperators
03815                                                                                * \brief  Unite
03816                                                                                *contents of one
03817                                                                                *entity set with
03818                                                                                *another
03819                                                                                *
03820                                                                                ******************************************************************************/
03821 
03822 void iMesh_unite( iMesh_Instance instance,
03823                   /**< [in] iMesh instance handle */
03824                   const iBase_EntitySetHandle entity_set_1,
03825                   /**< [in] Entity set being united with another */
03826                   const iBase_EntitySetHandle entity_set_2,
03827                   /**< [in] Entity set being united with another */
03828                   iBase_EntitySetHandle* result_entity_set,
03829                   /**< [out] Pointer to entity set returned from function */
03830                   int* err
03831                   /**< [out] Returned Error status (see iBase_ErrorType) */
03832 );
03833 
03834 /***************************************************************************/ /**
03835                                                                                * \page imesh iMesh:
03836                                                                                *ITAPS Serial Mesh
03837                                                                                *Interface
03838                                                                                *
03839                                                                                * The ITAPS Mesh
03840                                                                                *Interface iMesh
03841                                                                                *provides a common
03842                                                                                *interface for
03843                                                                                * accessing mesh and
03844                                                                                *data associated with
03845                                                                                *a mesh. Applications
03846                                                                                *written to use this
03847                                                                                *interface can use a
03848                                                                                *variety of
03849                                                                                *implementations,
03850                                                                                *choosing the one
03851                                                                                *that best meets its
03852                                                                                *needs.  They can
03853                                                                                *also use tools
03854                                                                                *written to this
03855                                                                                *interface, for
03856                                                                                *example mesh
03857                                                                                *smoothing, adaptive
03858                                                                                *mesh refinement, and
03859                                                                                *parallel mesh
03860                                                                                *support.
03861                                                                                *
03862                                                                                * The ITAPS
03863                                                                                *interfaces use a
03864                                                                                *data model composed
03865                                                                                *of four basic data
03866                                                                                *types: /Entity/:
03867                                                                                *basic topological
03868                                                                                *entities in a mesh,
03869                                                                                *e.g. vertices,
03870                                                                                * triangles,
03871                                                                                *hexahedra. /Entity
03872                                                                                *Set/: arbitrary
03873                                                                                *grouping of other
03874                                                                                *entities and sets.
03875                                                                                * Entity sets also
03876                                                                                *support parent/child
03877                                                                                *relations with other
03878                                                                                *sets which are
03879                                                                                *distinct from
03880                                                                                *entities contained
03881                                                                                *in those sets.
03882                                                                                *Parent/child links
03883                                                                                * can be used to
03884                                                                                *embed graph
03885                                                                                *relationships
03886                                                                                *between sets, e.g.
03887                                                                                *to represent
03888                                                                                *topological
03889                                                                                *relationships
03890                                                                                *between the sets.
03891                                                                                * /Interface/: the
03892                                                                                *object with which
03893                                                                                *mesh is associated
03894                                                                                *and on which
03895                                                                                * functions in iMesh
03896                                                                                *are called. /Tag/:
03897                                                                                *application data
03898                                                                                *associated with
03899                                                                                *objects of any of
03900                                                                                *the other data
03901                                                                                *types.  Each tag has
03902                                                                                *a designated name,
03903                                                                                *size, and data type.
03904                                                                                *
03905                                                                                * ITAPS Entity Type,
03906                                                                                *Topology Each entity
03907                                                                                *has a specific
03908                                                                                *Entity Type and
03909                                                                                *Entity Topology. The
03910                                                                                *Entity Type is one
03911                                                                                *of VERTEX, EDGE,
03912                                                                                *FACE, and REGION,
03913                                                                                *and is synonymous
03914                                                                                *with the topological
03915                                                                                *dimension of the
03916                                                                                *entity.  The Entity
03917                                                                                *Topology denotes the
03918                                                                                *specific shape, for
03919                                                                                *example TRIANGLE,
03920                                                                                *QUADRILATERAL,
03921                                                                                *TETRAHEDRON, and
03922                                                                                *HEXAHEDRON.  Entity
03923                                                                                *Type and Entity
03924                                                                                *Topology exist as
03925                                                                                *enumerated types,
03926                                                                                *Entity Type in the
03927                                                                                *iBase_EntityType
03928                                                                                *enumeration, and
03929                                                                                * Entity Topology in
03930                                                                                *the
03931                                                                                *iMesh_EntityTopology
03932                                                                                *enumeration.
03933                                                                                *
03934                                                                                * ITAPS Entity-,
03935                                                                                *Array-, and
03936                                                                                *Iterator-Based
03937                                                                                *Access The iMesh
03938                                                                                *interface provides
03939                                                                                *functions for
03940                                                                                *accessing entities
03941                                                                                * individually, as
03942                                                                                *arrays of entities,
03943                                                                                *or using iterators.
03944                                                                                *These access methods
03945                                                                                *have different
03946                                                                                *memory versus
03947                                                                                *execution time
03948                                                                                *tradeoffs, depending
03949                                                                                *on the
03950                                                                                *implementation.
03951                                                                                *
03952                                                                                * \image html
03953                                                                                *example_pic.jpeg
03954                                                                                *
03955                                                                                * \subpage cycles
03956                                                                                *
03957                                                                                * \page cycles Cycles
03958                                                                                *in Set-Inclusion and
03959                                                                                *Parent-Child
03960                                                                                *structures.
03961                                                                                *
03962                                                                                * There are two
03963                                                                                *graph-like
03964                                                                                *structures in the
03965                                                                                *iMesh interface and
03966                                                                                *data model; the
03967                                                                                *set-inclusion
03968                                                                                *structure and the
03969                                                                                *parent-child link
03970                                                                                *structure. Whether
03971                                                                                *these structures
03972                                                                                *support cycles is
03973                                                                                *relevant to
03974                                                                                *implementors.
03975                                                                                *
03976                                                                                * Over the evolution
03977                                                                                *of the iMesh data
03978                                                                                *model and API, both
03979                                                                                *of these structures
03980                                                                                *have been viewed
03981                                                                                *more or less like a
03982                                                                                *tree and so cycles
03983                                                                                *seem incompatible
03984                                                                                *with that notion.
03985                                                                                *
03986                                                                                * Allowing a cycle in
03987                                                                                *the set inclusion
03988                                                                                *structure implies
03989                                                                                *all entity sets in
03990                                                                                *the cycle are all
03991                                                                                *equal to each other.
03992                                                                                *That is the only
03993                                                                                *rational,
03994                                                                                * model-level view
03995                                                                                *that would allow
03996                                                                                *them all to be
03997                                                                                *(improper) subsets
03998                                                                                *of each other. On
03999                                                                                *the other hand if
04000                                                                                *the iMesh
04001                                                                                *specification
04002                                                                                *excludes cycles from
04003                                                                                *the set inclusion
04004                                                                                *structure, the time
04005                                                                                *complexity
04006                                                                                *(performance) as a
04007                                                                                * function of the
04008                                                                                *number of entity
04009                                                                                *sets may be
04010                                                                                *prohibitive for
04011                                                                                * implementations to
04012                                                                                *detect and prevent
04013                                                                                *them.
04014                                                                                *
04015                                                                                * Allowing a cycle in
04016                                                                                *the parent-child
04017                                                                                *link structure seems
04018                                                                                *likewise hard to
04019                                                                                *justify. However,
04020                                                                                *when the
04021                                                                                *parent-child
04022                                                                                *structure is viewed
04023                                                                                *more like a general
04024                                                                                *graph (a view that
04025                                                                                *the current API
04026                                                                                *itself supports even
04027                                                                                *if the function
04028                                                                                *names themselves do
04029                                                                                *not suggest that)
04030                                                                                *than specifically a
04031                                                                                *tree, the admission
04032                                                                                *of cycles there is
04033                                                                                *potentially more
04034                                                                                *natural and useful.
04035                                                                                *
04036                                                                                * Implementations are
04037                                                                                *required to support
04038                                                                                *cycles in the
04039                                                                                *Parent-Child
04040                                                                                * structure.
04041                                                                                *Implementations are
04042                                                                                *neither required to
04043                                                                                *support nor required
04044                                                                                * to explicitly
04045                                                                                *prevent cycles in
04046                                                                                *the Set-Inclusion
04047                                                                                *structure. Portable
04048                                                                                * applications should
04049                                                                                *NOT rely on
04050                                                                                *implementations
04051                                                                                *support for cycles
04052                                                                                * in the
04053                                                                                *set-inclusion
04054                                                                                *structure.
04055                                                                                ******************************************************************************/
04056 
04057 /***************************************************************************/ /**
04058                                                                                * \defgroup iMesh
04059                                                                                *iMesh
04060                                                                                ******************************************************************************/
04061 
04062 /***************************************************************************/ /**
04063                                                                                * \defgroup
04064                                                                                *Initialization
04065                                                                                *Initialization
04066                                                                                * \ingroup iMesh
04067                                                                                ******************************************************************************/
04068 
04069 /***************************************************************************/ /**
04070                                                                                * \defgroup Entities
04071                                                                                *Entities \ingroup
04072                                                                                *iMesh
04073                                                                                ******************************************************************************/
04074 
04075 /***************************************************************************/ /**
04076                                                                                * \defgroup
04077                                                                                *VertexEntities
04078                                                                                *Vertex Entities
04079                                                                                * \ingroup Entities
04080                                                                                ******************************************************************************/
04081 
04082 /***************************************************************************/ /**
04083                                                                                * \defgroup
04084                                                                                *EntitySets Entity
04085                                                                                *Sets \ingroup iMesh
04086                                                                                ******************************************************************************/
04087 
04088 /***************************************************************************/ /**
04089                                                                                * \defgroup
04090                                                                                *EntitySetOperators
04091                                                                                *Entity Set Operators
04092                                                                                * \ingroup EntitySets
04093                                                                                ******************************************************************************/
04094 
04095 /***************************************************************************/ /**
04096                                                                                * \defgroup
04097                                                                                *Adjacencies
04098                                                                                *Adjacencies \ingroup
04099                                                                                *iMesh
04100                                                                                ******************************************************************************/
04101 
04102 /***************************************************************************/ /**
04103                                                                                * \defgroup
04104                                                                                *EntityIterators
04105                                                                                *Entity Iterators
04106                                                                                * \ingroup iMesh
04107                                                                                ******************************************************************************/
04108 
04109 /***************************************************************************/ /**
04110                                                                                * \defgroup Tags Tags
04111                                                                                * \ingroup iMesh
04112                                                                                ******************************************************************************/
04113 
04114 /***************************************************************************/ /**
04115                                                                                * \defgroup TagData
04116                                                                                *Tag Data \ingroup
04117                                                                                *iMesh
04118                                                                                ******************************************************************************/
04119 
04120 /***************************************************************************/ /**
04121                                                                                * \defgroup
04122                                                                                *TagsOnEnts Tag Data
04123                                                                                *On Entities \ingroup
04124                                                                                *TagData
04125                                                                                ******************************************************************************/
04126 
04127 /***************************************************************************/ /**
04128                                                                                * \defgroup
04129                                                                                *TagsOnSets Tag Data
04130                                                                                *On Entity Sets
04131                                                                                * \ingroup TagData
04132                                                                                ******************************************************************************/
04133 
04134 /***************************************************************************/ /**
04135                                                                                * \defgroup TagsOnArr
04136                                                                                *Tag Data On Arrays
04137                                                                                *of Entities \ingroup
04138                                                                                *TagData
04139                                                                                ******************************************************************************/
04140 
04141 /***************************************************************************/ /**
04142                                                                                * \defgroup
04143                                                                                *MeshModification
04144                                                                                *Mesh Modification
04145                                                                                * \ingroup iMesh
04146                                                                                ******************************************************************************/
04147 
04148 /***************************************************************************/ /**
04149                                                                                * \defgroup
04150                                                                                *ParentChildLinks
04151                                                                                *Parent Child Links
04152                                                                                * \ingroup iMesh
04153                                                                                ******************************************************************************/
04154 
04155 /***************************************************************************/ /**
04156                                                                                * \defgroup Datatypes
04157                                                                                *Datatypes \ingroup
04158                                                                                *iMesh
04159                                                                                ******************************************************************************/
04160 
04161 #ifdef __cplusplus
04162 } /* extern "C" */
04163 #endif
04164 
04165 #endif /* ifndef _ITAPS_iMesh */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines