iMesh_MOAB.cpp

Go to the documentation of this file.

#include "moab/MOABConfig.h"
#include "iMesh_extensions.h"
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/CN.hpp"
#include "moab/MeshTopoUtil.hpp"
#include "moab/ScdInterface.hpp"
#include "moab/FileOptions.hpp"
#include "iMesh_MOAB.hpp"
#include "MBIter.hpp"
#include "MBTagConventions.hpp"
#define IS_BUILDING_MB
#include "Internals.hpp"
#undef IS_BUILDING_MB

#ifdef MOAB_HAVE_MPI
#include "moab_mpi.h"
#include "moab/ParallelComm.hpp"
#endif

#define STRINGIFY_( X ) #X
#define STRINGIFY( X )  STRINGIFY_( X )
#ifdef MOAB_HAVE_UNORDERED_MAP
#include STRINGIFY( MOAB_HAVE_UNORDERED_MAP )
#else
#include 
#endif

#include 
#include 
#include 
#include 
#include 
#include 
#define MIN( a, b ) ( ( a ) < ( b ) ? ( a ) : ( b ) )

#ifdef _WIN32
#define snprintf( A, B, C, D ) _snprintf( ( A ), ( B ), ( C ), ( D ) )
#endif

static ErrorCode create_int_ents( MBiMesh* mbimesh, Range& from_ents, const EntityHandle* in_set = 0 );
#define HANDLE_ARRAY_PTR( array )       ( reinterpret_cast< EntityHandle* >( array ) )
#define CONST_HANDLE_ARRAY_PTR( array ) reinterpret_cast< const EntityHandle* >( array )
#define TAG_HANDLE( handle )            reinterpret_cast< Tag >( handle )
#define CONST_TAG_HANDLE( handle )      static_cast< const Tag >( handle )
#define ENTITY_HANDLE( handle )         reinterpret_cast< EntityHandle >( handle )
#define CONST_ENTITY_HANDLE( handle )   reinterpret_cast< const EntityHandle >( handle )
#define CAST_TO_VOID( ptr )             ( reinterpret_cast< void* >( ptr ) )

// map from MB's entity type to TSTT's entity topology
const iMesh_EntityTopology tstt_topology_table[] = {
    iMesh_POINT,           // MBVERTEX
    iMesh_LINE_SEGMENT,    // MBEDGE
    iMesh_TRIANGLE,        // MBTRI
    iMesh_QUADRILATERAL,   // MBQUAD
    iMesh_POLYGON,         // MBPOLYGON
    iMesh_TETRAHEDRON,     // MBTET
    iMesh_PYRAMID,         // MBPYRAMID
    iMesh_PRISM,           // MBPRISM
    iMesh_ALL_TOPOLOGIES,  // MBKNIFE
    iMesh_HEXAHEDRON,      // MBHEX
    iMesh_POLYHEDRON,      // MBPOLYHEDRON
    iMesh_ALL_TOPOLOGIES,  // MBENTITYSET
    iMesh_ALL_TOPOLOGIES,  // MBMAXTYPE
};

// map from MB's entity type to TSTT's entity type
const iBase_EntityType tstt_type_table[] = {
    iBase_VERTEX,     // MBVERTEX
    iBase_EDGE,       // MBEDGE
    iBase_FACE,       // MBTRI
    iBase_FACE,       // MBQUAD
    iBase_FACE,       // MBPOLYGON
    iBase_REGION,     // MBTET
    iBase_REGION,     // MBPYRAMID
    iBase_REGION,     // MBPRISM
    iBase_REGION,     // MBKNIFE
    iBase_REGION,     // MBHEX
    iBase_REGION,     // MBPOLYHEDRON
    iBase_ALL_TYPES,  // MBENTITYSET
    iBase_ALL_TYPES   // MBMAXTYPE
};

// map to MB's entity type from TSTT's entity topology
const EntityType mb_topology_table[] = { MBVERTEX, MBEDGE, MBPOLYGON, MBTRI,     MBQUAD,    MBPOLYHEDRON,
                                         MBTET,    MBHEX,  MBPRISM,   MBPYRAMID, MBMAXTYPE, MBMAXTYPE };

// map from TSTT's tag types to MOAB's
const DataType mb_data_type_table[] = { MB_TYPE_OPAQUE, MB_TYPE_INTEGER, MB_TYPE_DOUBLE, MB_TYPE_HANDLE,
                                        MB_TYPE_HANDLE };

// map from MOAB's tag types to tstt's
const iBase_TagValueType tstt_data_type_table[] = { iBase_BYTES, iBase_INTEGER, iBase_DOUBLE, iBase_BYTES,
                                                    iBase_ENTITY_HANDLE };

const iBase_ErrorType iBase_ERROR_MAP[MB_FAILURE + 1] = {
    iBase_SUCCESS,                   // MB_SUCCESS = 0,
    iBase_INVALID_ENTITY_HANDLE,     // MB_INDEX_OUT_OF_RANGE,
    iBase_INVALID_ENTITY_TYPE,       // MB_TYPE_OUT_OF_RANGE,
    iBase_MEMORY_ALLOCATION_FAILED,  // MB_MEMORY_ALLOCATION_FAILED,
    iBase_INVALID_ENTITY_HANDLE,     // MB_ENTITY_NOT_FOUND,
    iBase_NOT_SUPPORTED,             // MB_MULTIPLE_ENTITIES_FOUND,
    iBase_TAG_NOT_FOUND,             // MB_TAG_NOT_FOUND,
    iBase_FILE_NOT_FOUND,            // MB_FILE_DOES_NOT_EXIST,
    iBase_FILE_WRITE_ERROR,          // MB_FILE_WRITE_ERROR,
    iBase_NOT_SUPPORTED,             // MB_NOT_IMPLEMENTED,
    iBase_TAG_ALREADY_EXISTS,        // MB_ALREADY_ALLOCATED,
    iBase_FAILURE,                   // MB_VARIABLE_DATA_LENGTH,
    iBase_FAILURE,                   // MB_INVALID_SIZE,
    iBase_NOT_SUPPORTED,             // MB_UNSUPPORTED_OPERATION,
    iBase_INVALID_ARGUMENT,          // MB_UNHANDLED_OPTION
    iBase_INVALID_ENTITY_TYPE,       // MB_STRUCTURED_MESH
    iBase_FAILURE                    // MB_FAILURE};
};

// Return data about a list of handles for use in check_handle_tag_type.
// Set output arguments to true if the list contains the corresponding
// type of handle.  Leave them unmodified if it does not.
static inline void ht_content_type( const std::vector< EntityHandle >& h, bool& saw_ent, bool& saw_set, bool& saw_root )
{
    std::vector< EntityHandle >::const_iterator i;
    for( i = h.begin(); i != h.end(); ++i )
    {
        if( *i == 0 )
            saw_root = true;
        else if( TYPE_FROM_HANDLE( *i ) == MBENTITYSET )
            saw_set = true;
        else
            saw_ent = true;
    }
}

// Scan all tag data to try to guess whether the MOAB tag with
// data of type MB_TYPE_HANDLE is iBase_ENTITY_HANDLE or
// iBase_ENTITY_SET_HANDLE.
static ErrorCode check_handle_tag_type( Tag t, MBiMesh* mbi )
{
    Interface* mb = mbi->mbImpl;
    ErrorCode rval;
    int size;
    DataType type;
    rval = mb->tag_get_data_type( t, type );
    if( MB_SUCCESS != rval ) return rval;
    if( MB_TYPE_HANDLE != type ) return MB_TYPE_OUT_OF_RANGE;
    rval = mb->tag_get_length( t, size );
    if( MB_SUCCESS != rval ) return rval;
    std::vector< EntityHandle > data( size );

    // check for global/mesh value
    bool saw_set = false, saw_ent = false, saw_root = false;
    EntityHandle root = 0;
    rval              = mb->tag_get_data( t, &root, 1, &data[0] );
    if( MB_SUCCESS == rval ) ht_content_type( data, saw_ent, saw_set, saw_root );

    // check default value
    rval = mb->tag_get_default_value( t, &data[0] );
    if( MB_SUCCESS == rval ) ht_content_type( data, saw_ent, saw_set, saw_root );

    // check all tagged entities
    Range r;
    rval = mb->get_entities_by_type_and_tag( 0, MBMAXTYPE, &t, 0, 1, r );
    if( MB_SUCCESS != rval ) return rval;
    for( Range::iterator i = r.begin(); i != r.end(); ++i )
    {
        rval = mb->tag_get_data( t, &*i, 1, &data[0] );
        if( MB_SUCCESS != rval ) return rval;
        ht_content_type( data, saw_ent, saw_set, saw_root );
    }

    // If tag values were only entities, note type accordingly.
    // Similarly if all are entity sets, note accordingly.
    // Because root set (zero handle) is sometimes used to mean NULL
    // rather than the actual root set, treat that specially.  If
    // all values are either root set or an entity handle, then
    // treat as if all values were non-set handles.
    if( saw_set && !saw_ent )
        mbi->note_set_handle_tag( t );
    else if( !saw_set && saw_ent )
        mbi->note_ent_handle_tag( t );
    else if( saw_root && !saw_ent )
        mbi->note_set_handle_tag( t );

    return MB_SUCCESS;
}

static void remove_var_len_tags( Interface* mb, std::vector< Tag >& tags )
{
    int size;
    size_t r, w = 0;
    for( r = 0; r < tags.size(); ++r )
        if( MB_SUCCESS == mb->tag_get_length( tags[r], size ) ) tags[w++] = tags[r];
    tags.resize( w );
}

// modify the adjacency table to match the ITAPS spec's expectations
static void munge_adj_table( int* adjTable, int geom_dim )
{
    // If geom_dim is 2, 3D adjacencies are unavailable. This may change!
    if( geom_dim == 2 )
    {
        for( size_t i = 0; i < 16; ++i )
        {
            if( i % 4 == 3 || i >= 12 ) adjTable[i] = iBase_UNAVAILABLE;
        }
    }

    // Ensure that diagonal entries are only available/unavailable.
    for( size_t i = 0; i < 16; i += 5 )
    {
        if( adjTable[i] != iBase_UNAVAILABLE ) adjTable[i] = iBase_AVAILABLE;
    }
}

#ifdef __cplusplus
extern "C" {
#endif

static void eatwhitespace( std::string& this_string );

void iMesh_getErrorType( iMesh_Instance instance, int* error_type )
{
    if( instance == NULL )
        *error_type = iBase_FAILURE;
    else
        *error_type = MBIMESHI->lastErrorType;
}

void iMesh_getDescription( iMesh_Instance instance, char* descr, int descr_len )
{
    if( instance == NULL )
    {
        strcpy( descr, "iMesh_getDescription: Invalid instance" );
    }
    else
    {
        unsigned int len = MIN( strlen( MBIMESHI->lastErrorDescription ), static_cast< unsigned int >( descr_len ) );
        strncpy( descr, MBIMESHI->lastErrorDescription, len );
        descr[len] = '\0';
    }
}

void iMesh_newMesh( const char* options, iMesh_Instance* instance, int* err, int options_len )
{
    std::string tmp_options = filter_options( options, options + options_len );
    FileOptions opts( tmp_options.c_str() );

    MBiMesh** mbi = reinterpret_cast< MBiMesh** >( instance );
    *mbi          = NULL;

    ErrorCode result = opts.get_null_option( "PARALLEL" );
    if( MB_SUCCESS == result )
    {
#ifdef MOAB_HAVE_MPI
        int flag   = 1;
        int retval = MPI_Initialized( &flag );
        if( MPI_SUCCESS != retval || !flag )
        {
            int argc    = 0;
            char** argv = NULL;

            // mpi not initialized yet - initialize here
            retval = MPI_Init( &argc, &argv );
            assert( MPI_SUCCESS == retval );
        }
        *mbi = new( std::nothrow ) MBiMesh( NULL );
#else
        // mError->set_last_error( "PARALLEL option not valid, this instance"
        //                        " compiled for serial execution.\n" );
        *mbi = new( std::nothrow ) MBiMesh( NULL );
        *err = ( *mbi )->set_last_error( MB_NOT_IMPLEMENTED, "Not configured with parallel support" );
        return;
#endif
    }
    else
    {
        *mbi = new( std::nothrow ) MBiMesh( NULL );
    }
    if( NULL == *mbi )
    {
        *err = iBase_FAILURE;
        return;
    }

    *err = iBase_SUCCESS;
}

void iMesh_dtor( iMesh_Instance instance, int* err )
{
    delete MBIMESHI;
    *err = iBase_SUCCESS;
}

void iMesh_load( iMesh_Instance instance,
                 const iBase_EntitySetHandle handle,
                 const char* name,
                 const char* options,
                 int* err,
                 int name_len,
                 int options_len )
{
    // get filename, option & null-terminate
    std::string filename( name, name_len );
    eatwhitespace( filename );

    std::string opts = filter_options( options, options + options_len );

    Range orig_ents;
    ErrorCode result = MOABI->get_entities_by_handle( 0, orig_ents );CHKERR( result, "Internal error" );

    const EntityHandle* file_set = 0;
    if( handle != 0 /*root_set*/ )
    {
        const iBase_EntitySetHandle* ptr = &handle;
        file_set                         = reinterpret_cast< const EntityHandle* >( ptr );
    }

    result = MOABI->load_file( filename.c_str(), file_set, opts.c_str() );

    CHKERR( result, "iMesh_load:ERROR loading a mesh." );

    // create interior edges/faces if requested
    if( MBIMESHI->AdjTable[5] || MBIMESHI->AdjTable[10] )
    {
        Range set_ents;
        result = MOABI->get_entities_by_handle( 0, set_ents );CHKERR( result, "" );
        Range sets;
        result = MOABI->get_entities_by_type( 0, MBENTITYSET, sets );CHKERR( result, "" );
        set_ents = subtract( set_ents, sets );
        set_ents = subtract( set_ents, orig_ents );
        result   = create_int_ents( MBIMESHI, set_ents, file_set );CHKERR( result, "" );
    }
    RETURN( iBase_SUCCESS );
}

void iMesh_save( iMesh_Instance instance,
                 const iBase_EntitySetHandle handle,
                 const char* name,
                 const char* options,
                 int* err,
                 const int name_len,
                 int options_len )
{
    // get filename & attempt to NULL-terminate
    std::string filename( name, name_len );
    eatwhitespace( filename );
    std::string opts = filter_options( options, options + options_len );

    EntityHandle set = ENTITY_HANDLE( handle );
    ErrorCode result = MOABI->write_file( filename.c_str(), NULL, opts.c_str(), &set, 1 );

    CHKERR( result, "iMesh_save:ERROR saving a mesh." );
    RETURN( iBase_SUCCESS );
}

void iMesh_getRootSet( iMesh_Instance instance, iBase_EntitySetHandle* root_set, int* err )
{
    *root_set = 0;
    // return CAST_TO_VOID(MOABI->get_root_set());
    RETURN( iBase_SUCCESS );
}

void iMesh_getGeometricDimension( iMesh_Instance instance, int* geom_dim, int* err )
{
    MOABI->get_dimension( *geom_dim );
    RETURN( iBase_SUCCESS );
}

void iMesh_setGeometricDimension( iMesh_Instance instance, int geom_dim, int* err )
{
    ErrorCode rval = MOABI->set_dimension( geom_dim );CHKERR( rval, "iMesh_setGeometricDimension: failed" );

    RETURN( iBase_SUCCESS );
}

void iMesh_getDfltStorage( iMesh_Instance instance, int* order, int* err )
{
    *order = iBase_BLOCKED;
    RETURN( iBase_SUCCESS );
}

void iMesh_getAdjTable( iMesh_Instance instance,
                        int** adjacency_table,
                        /*inout*/ int* adjacency_table_allocated,
                        /*out*/ int* adjacency_table_size,
                        int* err )
{
    int geom_dim;
    iMesh_getGeometricDimension( instance, &geom_dim, err );

    ALLOC_CHECK_ARRAY_NOFAIL( adjacency_table, 16 );
    memcpy( *adjacency_table, MBIMESHI->AdjTable, 16 * sizeof( int ) );
    munge_adj_table( *adjacency_table, geom_dim );
    RETURN( iBase_SUCCESS );
}

void iMesh_setAdjTable( iMesh_Instance instance,
                        int* adj_table,
                        /*inout*/ int adj_table_size,
                        int* err )
{
    if( 16 != adj_table_size )
    {
        RETURN( iBase_INVALID_ARGUMENT );
    }

    int geom_dim;
    iMesh_getGeometricDimension( instance, &geom_dim, err );

    memcpy( MBIMESHI->AdjTable, adj_table, 16 * sizeof( int ) );
    munge_adj_table( adj_table, geom_dim );
    RETURN( iBase_SUCCESS );
}

void iMesh_getNumOfType( iMesh_Instance instance,
                         /*in*/ const iBase_EntitySetHandle entity_set_handle,
                         /*in*/ const int entity_type,
                         int* num_type,
                         int* err )
{
    iMesh_getNumOfTypeRec( instance, entity_set_handle, entity_type, false, num_type, err );
}

void iMesh_getNumOfTopo( iMesh_Instance instance,
                         /*in*/ const iBase_EntitySetHandle entity_set_handle,
                         /*in*/ const int entity_topology,
                         int* num_topo,
                         int* err )
{
    iMesh_getNumOfTopoRec( instance, entity_set_handle, entity_topology, false, num_topo, err );
}

void iMesh_optimize( iMesh_Instance instance, int* handles_invalidated, int* err )
{
    // TODO: implement this for real
    *handles_invalidated = 0;
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntities( iMesh_Instance instance,
                        /*in*/ const iBase_EntitySetHandle entity_set_handle,
                        /*in*/ const int entity_type,
                        /*in*/ const int entity_topology,
                        /*inout*/ iBase_EntityHandle** entity_handles,
                        /*inout*/ int* entity_handles_allocated,
                        /*out*/ int* entity_handles_size,
                        int* err )
{
    iMesh_getEntitiesRec( instance, entity_set_handle, entity_type, entity_topology, false, entity_handles,
                          entity_handles_allocated, entity_handles_size, err );
}

void iMesh_getVtxArrCoords( iMesh_Instance instance,
                            /*in*/ const iBase_EntityHandle* vertex_handles,
                            /*in*/ const int vertex_handles_size,
                            /*inout*/ int storage_order,
                            /*inout*/ double** coords,
                            /*inout*/ int* coords_allocated,
                            /*out*/ int* coords_size,
                            int* err )
{
    int geom_dim;
    MOABI->get_dimension( geom_dim );

    // make sure we can hold them all
    ALLOC_CHECK_ARRAY( coords, geom_dim * vertex_handles_size );

    // now get all the coordinates
    // coords will come back interleaved by default
    ErrorCode result;
    if( storage_order == iBase_INTERLEAVED )
    {
        if( 3 == geom_dim )
        {
            result = MOABI->get_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, *coords );
        }
        else
        {
            std::vector< double > dum_coords( 3 * vertex_handles_size );
            result = MOABI->get_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, &dum_coords[0] );

            for( int i = 0; i < vertex_handles_size; i++ )
            {
                for( int j = 0; j < geom_dim; j++ )
                    ( *coords )[geom_dim * i + j] = dum_coords[3 * i + j];
            }
        }
    }
    else
    {
        std::vector< double > dum_coords( 3 * vertex_handles_size );
        result = MOABI->get_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, &dum_coords[0] );CHKERR( result, "iMesh_getVtxArrCoords: problem getting vertex coords" );

        for( int i = 0; i < vertex_handles_size; i++ )
        {
            for( int j = 0; j < geom_dim; j++ )
                ( *coords )[i + vertex_handles_size * j] = dum_coords[3 * i + j];
        }
    }

    KEEP_ARRAY( coords );
    RETURN( iBase_SUCCESS );
}

/**
 * Method:  initEntArrIter[]
 */
void iMesh_initEntArrIter( iMesh_Instance instance,
                           /*in*/ const iBase_EntitySetHandle entity_set_handle,
                           /*in*/ const int requested_entity_type,
                           /*in*/ const int requested_entity_topology,
                           /*in*/ const int requested_array_size,
                           /*in*/ const int resilient,
                           /*out*/ iBase_EntityArrIterator* entArr_iterator,
                           int* err )
{
    iMesh_initEntArrIterRec( instance, entity_set_handle, requested_entity_type, requested_entity_topology,
                             requested_array_size, resilient, false, entArr_iterator, err );
}

/**
 * Method:  getEntArrNextIter[]
 */
void iMesh_getNextEntArrIter( iMesh_Instance instance,
                              /*in*/ iBase_EntityArrIterator entArr_iterator,
                              /*inout*/ iBase_EntityHandle** entity_handles,
                              /*inout*/ int* entity_handles_allocated,
                              /*out*/ int* entity_handles_size,
                              int* has_data,
                              int* err )
{
    // check the size of the destination array
    ALLOC_CHECK_ARRAY_NOFAIL( entity_handles, entArr_iterator->array_size() );
    entArr_iterator->get_entities( dynamic_cast< Core* >( MOABI ), (EntityHandle*)*entity_handles,
                                   *entity_handles_size );
    *has_data = ( *entity_handles_size != 0 );
    RETURN( iBase_SUCCESS );
}

/**
 * Method:  resetEntArrIter[]
 */
void iMesh_resetEntArrIter( iMesh_Instance instance,
                            /*in*/ iBase_EntityArrIterator entArr_iterator,
                            int* err )
{
    ErrorCode result = entArr_iterator->reset( MOABI );CHKERR( result, "Re-query of iterator data for iMesh_resetEntArrIter failed" );
    RETURN( iBase_SUCCESS );
}

void iMesh_endEntArrIter( iMesh_Instance instance,
                          /*in*/ iBase_EntityArrIterator entArr_iterator,
                          int* err )
{
    delete entArr_iterator;
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntArrTopo( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*inout*/ int** topology,
                          /*inout*/ int* topology_allocated,
                          /*out*/ int* topology_size,
                          int* err )
{
    // go through each entity and look up its type
    ALLOC_CHECK_ARRAY_NOFAIL( topology, entity_handles_size );

    for( int i = 0; i < entity_handles_size; i++ )
        ( *topology )[i] = tstt_topology_table[MOABI->type_from_handle( ENTITY_HANDLE( entity_handles[i] ) )];

    *topology_size = entity_handles_size;

    RETURN( iBase_SUCCESS );
}

void iMesh_getEntArrType( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*inout*/ int** etype,
                          /*inout*/ int* etype_allocated,
                          /*out*/ int* etype_size,
                          int* err )
{
    // go through each entity and look up its type
    ALLOC_CHECK_ARRAY_NOFAIL( etype, entity_handles_size );

    for( int i = 0; i < entity_handles_size; i++ )
        ( *etype )[i] = tstt_type_table[MOABI->type_from_handle( ENTITY_HANDLE( entity_handles[i] ) )];

    *etype_size = entity_handles_size;

    RETURN( iBase_SUCCESS );
}

void iMesh_getEntArrAdj( iMesh_Instance instance,
                         /*in*/ const iBase_EntityHandle* entity_handles,
                         /*in*/ const int entity_handles_size,
                         /*in*/ const int entity_type_requested,
                         /*inout*/ iBase_EntityHandle** adjacentEntityHandles,
                         /*inout*/ int* adjacentEntityHandles_allocated,
                         /*out*/ int* adjacentEntityHandles_size,
                         /*inout*/ int** offset,
                         /*inout*/ int* offset_allocated,
                         /*out*/ int* offset_size,
                         int* err )
{
    ErrorCode result = MB_SUCCESS;

    ALLOC_CHECK_ARRAY( offset, entity_handles_size + 1 );

    const EntityHandle* entity_iter      = (const EntityHandle*)entity_handles;
    const EntityHandle* const entity_end = entity_iter + entity_handles_size;
    int* off_iter                        = *offset;
    int prev_off                         = 0;

    std::vector< EntityHandle > conn_storage;
    std::vector< EntityHandle > adj_ents;
    const EntityHandle* connect;
    int num_connect;

    EntityHandle* array;  // ptr to working array of result handles
    int array_alloc;      // allocated size of 'array'
    const bool allocated_array = !*adjacentEntityHandles_allocated || !*adjacentEntityHandles;
    if( allocated_array )
    {
        array       = 0;
        array_alloc = 0;
    }
    else
    {
        array       = reinterpret_cast< EntityHandle* >( *adjacentEntityHandles );
        array_alloc = *adjacentEntityHandles_allocated;
    }

    for( ; entity_iter != entity_end; ++entity_iter )
    {
        *off_iter = prev_off;
        off_iter++;

        if( iBase_VERTEX == entity_type_requested && TYPE_FROM_HANDLE( *entity_iter ) != MBPOLYHEDRON )
        {
            if( CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) ) == 0 ) continue;
            result = MOABI->get_connectivity( *entity_iter, connect, num_connect, false, &conn_storage );
            if( MB_SUCCESS != result )
            {
                if( allocated_array ) free( array );
                ERROR( result, "iMesh_getEntArrAdj: trouble getting adjacency list." );
            }
        }
        else if( iBase_ALL_TYPES == entity_type_requested )
        {
            adj_ents.clear();
            for( int dim = 0; dim < 4; ++dim )
            {
                if( CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) ) == dim ) continue;
                result = MOABI->get_adjacencies( entity_iter, 1, dim, false, adj_ents, Interface::UNION );
                if( MB_SUCCESS != result )
                {
                    if( allocated_array ) free( array );
                    ERROR( result, "iMesh_getEntArrAdj: trouble getting adjacency list." );
                }
            }
            connect     = &adj_ents[0];
            num_connect = adj_ents.size();
        }
        else
        {
            if( CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) ) == entity_type_requested ) continue;
            adj_ents.clear();
            result = MOABI->get_adjacencies( entity_iter, 1, entity_type_requested, false, adj_ents );
            if( MB_SUCCESS != result )
            {
                if( allocated_array ) free( array );
                ERROR( result, "iMesh_getEntArrAdj: trouble getting adjacency list." );
            }
            connect     = &adj_ents[0];
            num_connect = adj_ents.size();
        }

        if( prev_off + num_connect <= array_alloc )
        {
            std::copy( connect, connect + num_connect, array + prev_off );
        }
        else if( allocated_array )
        {
            // if array is not allocated yet, guess at initial size
            // as the number of adjacencies for the first entity times
            // the number of input entities.  This will result in a single
            // exact allocation if one input entity or typical queries
            // such as connectivity of a non-mixed mesh or regions adjacent
            // to faces.
            if( !array_alloc )
                array_alloc = entity_handles_size * num_connect;
            else
                array_alloc = std::max( array_alloc * 2, prev_off + num_connect );
            EntityHandle* new_array = (EntityHandle*)realloc( array, array_alloc * sizeof( EntityHandle ) );
            if( !new_array )
            {
                free( array );
                RETURN( iBase_MEMORY_ALLOCATION_FAILED );
            }
            else
                array = new_array;
            std::copy( connect, connect + num_connect, array + prev_off );
        }
        // else do nothing.  Will catch error later when comparing
        //  occupied to allocated sizes.  Continue here because
        //  must pass back required size.

        prev_off += num_connect;
    }
    *off_iter                   = prev_off;
    *adjacentEntityHandles_size = prev_off;

    if( *adjacentEntityHandles_size > array_alloc )
    {
        if( allocated_array ) free( array );
        RETURN( iBase_BAD_ARRAY_SIZE );
    }
    else if( allocated_array )
    {
        *adjacentEntityHandles           = reinterpret_cast< iBase_EntityHandle* >( array );
        *adjacentEntityHandles_allocated = array_alloc;
    }

    KEEP_ARRAY( offset );
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntArr2ndAdj( iMesh_Instance instance,
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int bridge_entity_type,
                            int requested_entity_type,
                            iBase_EntityHandle** adj_entity_handles,
                            int* adj_entity_handles_allocated,
                            int* adj_entity_handles_size,
                            int** offset,
                            int* offset_allocated,
                            int* offset_size,
                            int* err )
{
    CHKENUM( bridge_entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( requested_entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );

    ErrorCode result = MB_SUCCESS;

    ALLOC_CHECK_ARRAY( offset, entity_handles_size + 1 );

    const EntityHandle* entity_iter      = (const EntityHandle*)entity_handles;
    const EntityHandle* const entity_end = entity_iter + entity_handles_size;
    int* off_iter                        = *offset;
    int prev_off                         = 0;

    std::vector< EntityHandle > all_adj_ents;
    MeshTopoUtil mtu( MOABI );

    int min_bridge = iBase_VERTEX, max_bridge = iBase_REGION;
    int min_req = iBase_VERTEX, max_req = iBase_REGION;
    if( iBase_ALL_TYPES != bridge_entity_type ) min_bridge = max_bridge = bridge_entity_type;
    if( iBase_ALL_TYPES != requested_entity_type ) min_req = max_req = requested_entity_type;

    for( ; entity_iter != entity_end; ++entity_iter )
    {
        *off_iter = prev_off;
        off_iter++;
        Range adj_ents;

        int source = CN::Dimension( TYPE_FROM_HANDLE( *entity_iter ) );
        for( int bridge = min_bridge; bridge <= max_bridge; ++bridge )
        {
            if( source == bridge ) continue;
            for( int requested = min_req; requested <= max_req; ++requested )
            {
                if( bridge == requested ) continue;
                result = mtu.get_bridge_adjacencies( *entity_iter, bridge, requested, adj_ents );CHKERR( result, "iMesh_getEntArr2ndAdj: trouble getting adjacency list." );
            }
        }

        std::copy( adj_ents.begin(), adj_ents.end(), std::back_inserter( all_adj_ents ) );
        prev_off += adj_ents.size();
    }
    *off_iter = prev_off;

    ALLOC_CHECK_ARRAY_NOFAIL( adj_entity_handles, all_adj_ents.size() );
    memcpy( *adj_entity_handles, &all_adj_ents[0], sizeof( EntityHandle ) * all_adj_ents.size() );

    KEEP_ARRAY( offset );

    // Return an error if the bridge and requested entity types are different
    if( iBase_ALL_TYPES != bridge_entity_type && bridge_entity_type == requested_entity_type )
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_getEntArr2ndAdj: bridge and "
                                       "requested entity types must be different." );
    else
        RETURN( iBase_SUCCESS );
}

void iMesh_getAdjEntIndices( iMesh_Instance instance,
                             /*in*/ iBase_EntitySetHandle entity_set_handle,
                             /*in*/ int entity_type_requestor,
                             /*in*/ int entity_topology_requestor,
                             /*in*/ int entity_type_requested,
                             /*inout*/ iBase_EntityHandle** entity_handles,
                             /*inout*/ int* entity_handles_allocated,
                             /*out*/ int* entity_handles_size,
                             /*inout*/ iBase_EntityHandle** adj_entity_handles,
                             /*inout*/ int* adj_entity_handles_allocated,
                             /*out*/ int* adj_entity_handles_size,
                             /*inout*/ int** adj_entity_indices,
                             /*inout*/ int* adj_entity_indices_allocated,
                             /*out*/ int* adj_entity_indices_size,
                             /*inout*/ int** offset,
                             /*inout*/ int* offset_allocated,
                             /*out*/ int* offset_size,
                             /*out*/ int* err )
{
    const int allocated_entity_handles = ( *entity_handles_allocated == 0 );
    const int allocated_indices        = ( *adj_entity_indices_allocated == 0 );
    const int allocated_offset         = ( *offset_allocated == 0 );

    // get source entities
    iMesh_getEntities( instance, entity_set_handle, entity_type_requestor, entity_topology_requestor, entity_handles,
                       entity_handles_allocated, entity_handles_size, err );
    if( iBase_SUCCESS != *err ) return;

    // get adjacencies
    iBase_EntityHandle* all_adj_handles = 0;
    int size = 0, alloc = 0;
    iMesh_getEntArrAdj( instance, *entity_handles, *entity_handles_size, entity_type_requested, &all_adj_handles,
                        &alloc, &size, offset, offset_allocated, offset_size, err );
    if( *err != iBase_SUCCESS )
    {
        if( allocated_entity_handles )
        {
            free( *entity_handles );
            *entity_handles           = 0;
            *entity_handles_allocated = 0;
        }
        return;
    }

    // allocate or check size of adj_entity_indices
    *adj_entity_indices_size = size;
    if( allocated_indices )
    {
        *adj_entity_indices = (int*)malloc( sizeof( iBase_EntityHandle ) * size );
        if( !*adj_entity_indices )
            *err = iBase_MEMORY_ALLOCATION_FAILED;
        else
            *adj_entity_indices_allocated = size;
    }
    else if( *adj_entity_indices_allocated < size )
    {
        *err = iBase_BAD_ARRAY_DIMENSION;
    }
    if( iBase_SUCCESS != *err )
    {
        free( all_adj_handles );
        if( allocated_entity_handles )
        {
            free( *entity_handles );
            *entity_handles           = 0;
            *entity_handles_allocated = 0;
        }
        if( allocated_offset )
        {
            free( *offset );
            *offset           = 0;
            *offset_allocated = 0;
        }
        return;
    }

    // Now create an array of unique sorted handles from all_adj_handles.
    // We need to create a copy because we still need all_adj_handles.  We
    // will eventually need to copy the resulting unique list into
    // adj_entity_handles, so if adj_entity_handles is already allocated and
    // of sufficient size, use it rather than allocating another temporary.
    iBase_EntityHandle* unique_adj = 0;
    if( *adj_entity_handles_allocated >= size )
    {
        unique_adj = *adj_entity_handles;
    }
    else
    {
        unique_adj = (iBase_EntityHandle*)malloc( sizeof( iBase_EntityHandle ) * size );
    }
    std::copy( all_adj_handles, all_adj_handles + size, unique_adj );
    std::sort( unique_adj, unique_adj + size );
    *adj_entity_handles_size = std::unique( unique_adj, unique_adj + size ) - unique_adj;

    // If we created a temporary array for unique_adj rather than using
    // already allocated space in adj_entity_handles, allocate adj_entity_handles
    // and copy the unique handle list into it
    if( *adj_entity_handles != unique_adj )
    {
        if( !*adj_entity_handles_allocated )
        {
            *adj_entity_handles =
                (iBase_EntityHandle*)malloc( sizeof( iBase_EntityHandle ) * *adj_entity_handles_size );
            if( !*adj_entity_handles )
                *err = iBase_MEMORY_ALLOCATION_FAILED;
            else
                *adj_entity_handles_allocated = *adj_entity_handles_size;
        }
        else if( *adj_entity_handles_allocated < *adj_entity_handles_size )
            *err = iBase_BAD_ARRAY_DIMENSION;
        if( iBase_SUCCESS != *err )
        {
            free( unique_adj );
            free( all_adj_handles );
            if( allocated_entity_handles )
            {
                free( *entity_handles );
                *entity_handles           = 0;
                *entity_handles_allocated = 0;
            }
            if( allocated_offset )
            {
                free( *offset );
                *offset           = 0;
                *offset_allocated = 0;
            }
            if( allocated_indices )
            {
                free( *adj_entity_indices );
                *adj_entity_indices           = 0;
                *adj_entity_indices_allocated = 0;
            }
            return;
        }

        std::copy( unique_adj, unique_adj + *adj_entity_handles_size, *adj_entity_handles );
        free( unique_adj );
        unique_adj = *adj_entity_handles;
    }

    // convert from adjacency list to indices into unique_adj
    for( int i = 0; i < *adj_entity_indices_size; ++i )
        ( *adj_entity_indices )[i] =
            std::lower_bound( unique_adj, unique_adj + *adj_entity_handles_size, all_adj_handles[i] ) - unique_adj;
    free( all_adj_handles );
}

void iMesh_createEntSet( iMesh_Instance instance,
                         /*in*/ const int isList,
                         /*out*/ iBase_EntitySetHandle* entity_set_created,
                         int* err )
{
    // create the entity set
    EntityHandle meshset;
    ErrorCode result;

    if( isList )
        result = MOABI->create_meshset( MESHSET_ORDERED, meshset );
    else
        result = MOABI->create_meshset( MESHSET_SET, meshset );

    CHKERR( result, "iMesh_createEntSet: ERROR creating a entityset instance" );

    // return EntitySet_Handle
    *entity_set_created = (iBase_EntitySetHandle)meshset;
    RETURN( iBase_SUCCESS );
}

void iMesh_destroyEntSet( iMesh_Instance instance,
                          /*in*/ iBase_EntitySetHandle entity_set,
                          int* err )
{
    EntityHandle set = ENTITY_HANDLE( entity_set );
    ErrorCode result = MOABI->delete_entities( &set, 1 );CHKERR( result, "iMesh_destroyEntSet: couldn't delete the set." );

    RETURN( iBase_SUCCESS );
}

void iMesh_isList( iMesh_Instance instance,
                   /*in*/ const iBase_EntitySetHandle entity_set,
                   int* is_list,
                   int* err )
{
    unsigned int options;
    ErrorCode result = MOABI->get_meshset_options( ENTITY_HANDLE( entity_set ), options );CHKERR( result, "iMesh_isList: couldn't query set." );
    if( options & MESHSET_ORDERED )
        *is_list = true;
    else
        *is_list = false;

    RETURN( iBase_SUCCESS );
}

void iMesh_getNumEntSets( iMesh_Instance instance,
                          /*in*/ const iBase_EntitySetHandle entity_set_handle,
                          /*in*/ const int num_hops,
                          int* num_sets,
                          int* err )
{
    ErrorCode rval =
        MOABI->num_contained_meshsets( ENTITY_HANDLE( entity_set_handle ), num_sets, std::max( 0, num_hops + 1 ) );CHKERR( rval, "iMesh_entitysetGetNumberEntitySets:ERROR getting number of entitysets." );

    RETURN( iBase_SUCCESS );
}

void iMesh_getEntSets( iMesh_Instance instance,
                       /*in*/ const iBase_EntitySetHandle entity_set_handle,
                       /*in*/ const int num_hops,
                       /*inout*/ iBase_EntitySetHandle** contained_entset_handles,
                       /*inout*/ int* contained_entset_handles_allocated,
                       /*inout*/ int* contained_entset_handles_size,
                       int* err )
{
    std::vector< EntityHandle > sets;
    ErrorCode rval =
        MOABI->get_contained_meshsets( ENTITY_HANDLE( entity_set_handle ), sets, std::max( num_hops + 1, 0 ) );CHKERR( rval, "iMesh_entitysetGetEntitySets: problem getting entities by type." );
    ALLOC_CHECK_ARRAY_NOFAIL( contained_entset_handles, sets.size() );

    std::copy( sets.begin(), sets.end(), (EntityHandle*)*contained_entset_handles );
    *contained_entset_handles_size = sets.size();
    RETURN( iBase_SUCCESS );
}

void iMesh_addEntArrToSet( iMesh_Instance instance,
                           /*in*/ const iBase_EntityHandle* entity_handles,
                           /*in*/ int entity_handles_size,
                           /*in*/ iBase_EntitySetHandle entity_set,
                           int* err )
{
    const EntityHandle* ents = CONST_HANDLE_ARRAY_PTR( entity_handles );
    ErrorCode result         = MOABI->add_entities( ENTITY_HANDLE( entity_set ), ents, entity_handles_size );

    CHKERR( result, "iMesh_addEntArrToSet:ERROR adding entities in EntitySet." );
    RETURN( iBase_SUCCESS );
}

void iMesh_addEntToSet( iMesh_Instance instance,
                        /*in*/ iBase_EntityHandle entity_handle,
                        /*in*/ iBase_EntitySetHandle entity_set,
                        int* err )
{
    iMesh_addEntArrToSet( instance, &entity_handle, 1, entity_set, err );
}

void iMesh_rmvEntArrFromSet( iMesh_Instance instance,
                             /*in*/ const iBase_EntityHandle* entity_handles,
                             /*in*/ int entity_handles_size,
                             /*in*/ iBase_EntitySetHandle entity_set,
                             int* err )
{
    const EntityHandle* ents = CONST_HANDLE_ARRAY_PTR( entity_handles );

    ErrorCode result = MOABI->remove_entities( ENTITY_HANDLE( entity_set ), ents, entity_handles_size );

    CHKERR( result, "iMesh_rmvEntArrFromSet:ERROR removing entities in EntitySet." );
    RETURN( iBase_SUCCESS );
}

void iMesh_rmvEntFromSet( iMesh_Instance instance,
                          /*in*/ iBase_EntityHandle entity_handle,
                          /*in*/ iBase_EntitySetHandle entity_set,
                          int* err )
{
    iMesh_rmvEntArrFromSet( instance, &entity_handle, 1, entity_set, err );
}

void iMesh_addEntSet( iMesh_Instance instance,
                      /*in*/ iBase_EntitySetHandle entity_set_to_add,
                      /*in*/ iBase_EntitySetHandle entity_set_handle,
                      int* err )
{
    if( !entity_set_to_add || !entity_set_handle )
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_addEntSet: ERROR invalid argument" );

    EntityHandle to_add = ENTITY_HANDLE( entity_set_to_add );
    ErrorCode result    = MOABI->add_entities( ENTITY_HANDLE( entity_set_handle ), &to_add, 1 );

    CHKERR( result, "iMesh_addEntSet:ERROR adding entitysets." );
    RETURN( iBase_SUCCESS );
}

void iMesh_rmvEntSet( iMesh_Instance instance,
                      /*in*/ iBase_EntitySetHandle entity_set_to_remove,
                      /*in*/ iBase_EntitySetHandle entity_set_handle,
                      int* err )
{
    if( !entity_set_to_remove || !entity_set_handle )
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_rmvEntSet: ERROR invalid argument" );

    EntityHandle to_remove = ENTITY_HANDLE( entity_set_to_remove );
    ErrorCode result       = MOABI->remove_entities( ENTITY_HANDLE( entity_set_handle ), &to_remove, 1 );

    CHKERR( result, "iMesh_rmvEntSet:ERROR removing entitysets in EntitySet." );
    RETURN( iBase_SUCCESS );
}

void iMesh_isEntContained( iMesh_Instance instance,
                           /*in*/ iBase_EntitySetHandle containing_entity_set,
                           /*in*/ iBase_EntityHandle contained_entity,
                           int* is_contained,
                           int* err )
{
    int junk1 = 1, junk2 = 1;
    iMesh_isEntArrContained( instance, containing_entity_set, &contained_entity, 1, &is_contained, &junk1, &junk2,
                             err );
}

void iMesh_isEntArrContained( iMesh_Instance instance,
                              /*in*/ iBase_EntitySetHandle containing_set,
                              /*in*/ const iBase_EntityHandle* entity_handles,
                              /*in*/ int num_entity_handles,
                              /*inout*/ int** is_contained,
                              /*inout*/ int* is_contained_allocated,
                              /*out*/ int* is_contained_size,
                              /*out*/ int* err )

{
    EntityHandle set = ENTITY_HANDLE( containing_set );
    ALLOC_CHECK_ARRAY_NOFAIL( is_contained, num_entity_handles );
    *is_contained_size = num_entity_handles;

    if( containing_set )
    {
        for( int i = 0; i < num_entity_handles; ++i )
        {
            EntityHandle h       = ENTITY_HANDLE( entity_handles[i] );
            ( *is_contained )[i] = MOABI->contains_entities( set, &h, 1 );
        }
    }
    else
    {
        std::fill( *is_contained, ( *is_contained ) + num_entity_handles, 1 );
    }
    RETURN( iBase_SUCCESS );
}

void iMesh_isEntSetContained( iMesh_Instance instance,
                              /*in*/ const iBase_EntitySetHandle containing_entity_set,
                              /*in*/ const iBase_EntitySetHandle contained_entity_set,
                              int* is_contained,
                              int* err )
{
    iMesh_isEntContained( instance, containing_entity_set,
                          reinterpret_cast< iBase_EntityHandle >( contained_entity_set ), is_contained, err );
}

void iMesh_addPrntChld( iMesh_Instance instance,
                        /*inout*/ iBase_EntitySetHandle parent_entity_set,
                        /*inout*/ iBase_EntitySetHandle child_entity_set,
                        int* err )
{
    ErrorCode result = MOABI->add_parent_child( ENTITY_HANDLE( parent_entity_set ), ENTITY_HANDLE( child_entity_set ) );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_addPrntChld: ERROR invalid entity set." );CHKERR( result, "iMesh_addPrntChld: ERROR addParentChild failed." );
    RETURN( iBase_SUCCESS );
}

void iMesh_rmvPrntChld( iMesh_Instance instance,
                        /*inout*/ iBase_EntitySetHandle parent_entity_set,
                        /*inout*/ iBase_EntitySetHandle child_entity_set,
                        int* err )
{
    ErrorCode result =
        MOABI->remove_parent_child( ENTITY_HANDLE( parent_entity_set ), ENTITY_HANDLE( child_entity_set ) );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_rmvPrntChld: ERROR invalid entity set." );CHKERR( result, "iMesh_rmvPrntChld: ERROR RemoveParentChild failed." );
    RETURN( iBase_SUCCESS );
}

void iMesh_isChildOf( iMesh_Instance instance,
                      /*in*/ const iBase_EntitySetHandle parent_entity_set,
                      /*in*/ const iBase_EntitySetHandle child_entity_set,
                      int* is_child,
                      int* err )
{
    if( !child_entity_set ) ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_isChildOf: ERROR invalid entity set." );

    std::vector< EntityHandle > children;

    ErrorCode result = MOABI->get_child_meshsets( ENTITY_HANDLE( parent_entity_set ), children );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_rmvPrntChld: ERROR invalid entity set." );CHKERR( result, "iMesh_isChildOf: ERROR IsParentChildRelated failed." );

    if( std::find( children.begin(), children.end(), ENTITY_HANDLE( child_entity_set ) ) != children.end() )
        *is_child = true;

    else
        *is_child = false;

    RETURN( iBase_SUCCESS );
}

void iMesh_getNumChld( iMesh_Instance instance,
                       /*in*/ const iBase_EntitySetHandle entity_set,
                       /*in*/ const int num_hops,
                       int* num_child,
                       int* err )
{
    *num_child       = 0;
    ErrorCode result = MOABI->num_child_meshsets( ENTITY_HANDLE( entity_set ), num_child, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getNumChld: ERROR invalid entity set." );CHKERR( result, "iMesh_getNumChld: ERROR GetNumChildren failed." );

    RETURN( iBase_SUCCESS );
}

void iMesh_getNumPrnt( iMesh_Instance instance,
                       /*in*/ const iBase_EntitySetHandle entity_set,
                       /*in*/ const int num_hops,
                       int* num_parent,
                       int* err )
{
    *num_parent      = 0;
    ErrorCode result = MOABI->num_parent_meshsets( ENTITY_HANDLE( entity_set ), num_parent, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getNumPrnt: ERROR invalid entity set." );CHKERR( result, "iMesh_getNumPrnt: ERROR GetNumParents failed." );
    RETURN( iBase_SUCCESS );
}

void iMesh_getChldn( iMesh_Instance instance,
                     /*in*/ const iBase_EntitySetHandle from_entity_set,
                     /*in*/ const int num_hops,
                     /*out*/ iBase_EntitySetHandle** entity_set_handles,
                     /*out*/ int* entity_set_handles_allocated,
                     /*out*/ int* entity_set_handles_size,
                     int* err )
{
    std::vector< EntityHandle > children;

    ErrorCode result = MOABI->get_child_meshsets( ENTITY_HANDLE( from_entity_set ), children, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getChldn: ERROR invalid entity set." );CHKERR( result, "ERROR getChildren failed." );
    ALLOC_CHECK_ARRAY_NOFAIL( entity_set_handles, children.size() );

    EntityHandle* ents = HANDLE_ARRAY_PTR( *entity_set_handles );
    // use a memcpy for efficiency
    memcpy( ents, &children[0], children.size() * sizeof( EntityHandle ) );

    RETURN( iBase_SUCCESS );
}

void iMesh_getPrnts( iMesh_Instance instance,
                     /*in*/ const iBase_EntitySetHandle from_entity_set,
                     /*in*/ const int num_hops,
                     /*out*/ iBase_EntitySetHandle** entity_set_handles,
                     /*out*/ int* entity_set_handles_allocated,
                     /*out*/ int* entity_set_handles_size,
                     int* err )
{
    std::vector< EntityHandle > parents;

    ErrorCode result = MOABI->get_parent_meshsets( ENTITY_HANDLE( from_entity_set ), parents, num_hops + 1 );

    if( result == MB_ENTITY_NOT_FOUND )
        ERROR( iBase_INVALID_ENTITYSET_HANDLE, "iMesh_getPrnts: ERROR invalid entity set." );CHKERR( result, "ERROR getParents failed." );

    ALLOC_CHECK_ARRAY_NOFAIL( entity_set_handles, parents.size() );

    EntityHandle* ents = HANDLE_ARRAY_PTR( *entity_set_handles );
    // use a memcpy for efficiency
    memcpy( ents, &parents[0], parents.size() * sizeof( EntityHandle ) );

    RETURN( iBase_SUCCESS );
}

void iMesh_setVtxArrCoords( iMesh_Instance instance,
                            /*in*/ const iBase_EntityHandle* vertex_handles,
                            /*in*/ const int vertex_handles_size,
                            /*in*/ const int storage_order,
                            /*in*/ const double* new_coords,
                            /*in*/ const int new_coords_size,
                            int* err )
{
    CHKENUM( storage_order, iBase_StorageOrder, iBase_INVALID_ARGUMENT );

    int geom_dim;
    MOABI->get_dimension( geom_dim );
    if( new_coords_size != geom_dim * vertex_handles_size )
    {
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_setVtxArrCoords: Didn't get the right # coordinates." );
    }

    ErrorCode result = MB_SUCCESS, tmp_result;
    if( storage_order == iBase_INTERLEAVED )
    {
        if( 3 == geom_dim )
        {
            result = MOABI->set_coords( CONST_HANDLE_ARRAY_PTR( vertex_handles ), vertex_handles_size, new_coords );
        }
        else
        {
            const EntityHandle* verts = CONST_HANDLE_ARRAY_PTR( vertex_handles );
            double dummy[3]           = { 0, 0, 0 };
            for( int i = 0; i < vertex_handles_size; i++ )
            {
                for( int j = 0; j < geom_dim; j++ )
                    dummy[j] = new_coords[geom_dim * i + j];
                tmp_result = MOABI->set_coords( &verts[i], 1, dummy );
                if( MB_SUCCESS != tmp_result ) result = tmp_result;
            }
        }
    }
    else
    {
        const EntityHandle* verts = CONST_HANDLE_ARRAY_PTR( vertex_handles );
        double dummy[3]           = { 0, 0, 0 };
        for( int i = 0; i < vertex_handles_size; i++ )
        {
            for( int j = 0; j < geom_dim; j++ )
                dummy[j] = new_coords[i + vertex_handles_size * j];
            tmp_result = MOABI->set_coords( &verts[i], 1, dummy );
            if( MB_SUCCESS != tmp_result ) result = tmp_result;
        }
    }

    CHKERR( result, "iMesh_setVtxArrCoords: problem setting coordinates." );

    RETURN( iBase_SUCCESS );
}

void iMesh_createVtxArr( iMesh_Instance instance,
                         /*in*/ const int num_verts,
                         /*in*/ const int storage_order,
                         /*in*/ const double* new_coords,
                         /*in*/ const int new_coords_size,
                         /*inout*/ iBase_EntityHandle** new_vertex_handles,
                         /*inout*/ int* new_vertex_handles_allocated,
                         /*inout*/ int* new_vertex_handles_size,
                         int* err )
{
    int geom_dim;
    MOABI->get_dimension( geom_dim );
    if( new_coords_size != geom_dim * num_verts )
    {
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_createVtxArr: Didn't get the right # coordinates." );
    }

    // if there aren't any elements in the array, allocate it
    ALLOC_CHECK_ARRAY( new_vertex_handles, num_verts );

    // make the entities
    EntityHandle* new_verts = HANDLE_ARRAY_PTR( *new_vertex_handles );

    if( storage_order == iBase_INTERLEAVED )
    {
        if( 3 == geom_dim )
        {
            for( int i = 0; i < num_verts; i++ )
            {
                ErrorCode result = MOABI->create_vertex( &new_coords[3 * i], new_verts[i] );CHKERR( result, "iMesh_createVtxArr: couldn't create vertex." );
            }
        }
        else
        {
            double tmp[3] = { 0, 0, 0 };
            for( int i = 0; i < num_verts; i++ )
            {
                for( int j = 0; j < geom_dim; j++ )
                    tmp[j] = new_coords[geom_dim * i + j];
                ErrorCode result = MOABI->create_vertex( tmp, new_verts[i] );CHKERR( result, "iMesh_createVtxArr: couldn't create vertex." );
            }
        }
    }
    else
    {
        double tmp[3] = { 0, 0, 0 };
        for( int i = 0; i < num_verts; i++ )
        {
            for( int j = 0; j < geom_dim; j++ )
                tmp[j] = new_coords[j * num_verts + i];

            ErrorCode result = MOABI->create_vertex( tmp, new_verts[i] );CHKERR( result, "iMesh_createVtxArr: couldn't create vertex." );
        }
    }

    KEEP_ARRAY( new_vertex_handles );
    RETURN( iBase_SUCCESS );
}

void iMesh_createEntArr( iMesh_Instance instance,
                         /*in*/ const int new_entity_topology,
                         /*in*/ const iBase_EntityHandle* lower_order_entity_handles,
                         /*in*/ const int lower_order_entity_handles_size,
                         /*out*/ iBase_EntityHandle** new_entity_handles,
                         /*out*/ int* new_entity_handles_allocated,
                         /*out*/ int* new_entity_handles_size,
                         /*inout*/ int** status,
                         /*inout*/ int* status_allocated,
                         /*out*/ int* status_size,
                         int* err )
{
    // for now, throw an error if lower order entity handles aren't vertices
    if( iMesh_POINT > new_entity_topology || iMesh_SEPTAHEDRON < new_entity_topology )
    {
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_createEntArr: invalid topology." );
    }
    EntityType this_type = mb_topology_table[new_entity_topology];
    int num_ents         = 0, num_verts;
    const EntityHandle* lower_ents;
    if( MBVERTEX != this_type )
    {
        num_verts  = CN::VerticesPerEntity( this_type );
        num_ents   = lower_order_entity_handles_size / num_verts;
        lower_ents = CONST_HANDLE_ARRAY_PTR( lower_order_entity_handles );
        // check that we have the right number of lower order entity handles
        if( lower_order_entity_handles_size % CN::VerticesPerEntity( this_type ) != 0 )
        {
            ERROR( iBase_INVALID_ENTITY_COUNT, "iMesh_createEntArr: wrong # vertices for this entity type." );
        }
    }
    else
    {
        ERROR( iBase_INVALID_ARGUMENT, "iMesh_createEntArr: can't create vertices with this "
                                       "function, use createVtxArr instead." );
    }

    if( num_ents == 0 )
    {
        ERROR( iBase_INVALID_ENTITY_COUNT, "iMesh_createEntArr: called to create 0 entities." );
    }

    // if there aren't any elements in the array, allocate it

    // This function is poorly defined.  We have to return allocated
    // arrays even if we fail.
    ALLOC_CHECK_ARRAY_NOFAIL( new_entity_handles, num_ents );
    ALLOC_CHECK_ARRAY_NOFAIL( status, num_ents );

    // make the entities
    EntityHandle* new_ents = HANDLE_ARRAY_PTR( *new_entity_handles );

    ErrorCode tmp_result, result = MB_SUCCESS;

    for( int i = 0; i < num_ents; i++ )
    {
        tmp_result = MOABI->create_element( this_type, lower_ents, num_verts, new_ents[i] );
        if( MB_SUCCESS != tmp_result )
        {
            ( *status )[i] = iBase_CREATION_FAILED;
            result         = tmp_result;
        }
        else
            ( *status )[i] = iBase_NEW;

        lower_ents += num_verts;
    }

    CHKERR( result, "iMesh_createEntArr: couldn't create one of the entities." );

    *new_entity_handles_size = num_ents;
    *status_size             = num_ents;

    if( MBIMESHI->AdjTable[5] || MBIMESHI->AdjTable[10] )
    {
        Range set_ents;
        std::copy( HANDLE_ARRAY_PTR( *new_entity_handles ),
                   HANDLE_ARRAY_PTR( *new_entity_handles ) + *new_entity_handles_size, range_inserter( set_ents ) );
        result = create_int_ents( MBIMESHI, set_ents );CHKERR( result, "" );
    }

    RETURN( iBase_SUCCESS );
}

void iMesh_deleteEntArr( iMesh_Instance instance,
                         /*in*/ const iBase_EntityHandle* entity_handles,
                         /*in*/ const int entity_handles_size,
                         int* err )
{
    if( 0 == entity_handles_size )
    {
        RETURN( iBase_SUCCESS );
    }

    ErrorCode result = MOABI->delete_entities( CONST_HANDLE_ARRAY_PTR( entity_handles ), entity_handles_size );CHKERR( result, "iMesh_deleteEntArr: trouble deleting entities." );

    RETURN( iBase_SUCCESS );
}

void iMesh_createTag( iMesh_Instance instance,
                      /*in*/ const char* tag_name,
                      /*in*/ const int tag_size,
                      /*in*/ const int tag_type,
                      /*out*/ iBase_TagHandle* tag_handle,
                      int* err,
                      const int tag_name_size )
{
    iMesh_createTagWithOptions( instance, tag_name, NULL, tag_size, tag_type, tag_handle, err, tag_name_size, 0 );
}

void iMesh_destroyTag( iMesh_Instance instance,
                       /*in*/ iBase_TagHandle tag_handle,
                       /*in*/ const int forced,
                       int* err )
{
    // might need to check if it's used first
    if( false == forced )
    {
        Range ents;
        ErrorCode result;
        Tag this_tag = TAG_HANDLE( tag_handle );
        for( EntityType this_type = MBVERTEX; this_type != MBMAXTYPE; this_type++ )
        {
            result = MOABI->get_entities_by_type_and_tag( 0, this_type, &this_tag, NULL, 1, ents, Interface::UNION );CHKERR( result, "iMesh_destroyTag: problem finding tag." );
            if( !ents.empty() )
            {
                ERROR( iBase_TAG_IN_USE, "iMesh_destroyTag: forced=false and entities"
                                         " are still assigned this tag." );
            }
        }
        // check if tag value is set on mesh
        const void* data_ptr;
        EntityHandle root = 0;
        result            = MOABI->tag_get_by_ptr( this_tag, &root, 1, &data_ptr );
        if( MB_SUCCESS == result )
            ERROR( iBase_TAG_IN_USE, "iMesh_destroyTag: forced=false and mesh"
                                     " is still assigned this tag." );
    }

    // ok, good to go - either forced or no entities with this tag
    ErrorCode result = MOABI->tag_delete( TAG_HANDLE( tag_handle ) );
    if( MB_SUCCESS != result && MB_TAG_NOT_FOUND != result ) ERROR( result, "iMesh_destroyTag: problem deleting tag." );

    if( MB_SUCCESS == result ) MBIMESHI->note_tag_destroyed( TAG_HANDLE( tag_handle ) );

    RETURN( iBase_ERROR_MAP[result] );
}

void iMesh_getTagName( iMesh_Instance instance,
                       /*in*/ const iBase_TagHandle tag_handle,
                       char* out_data,
                       int* err,
                       int out_data_len )
{
    static ::std::string name;
    ErrorCode result = MOABI->tag_get_name( TAG_HANDLE( tag_handle ), name );CHKERR( result, "iMesh_getTagName: problem getting name." );

    strncpy( out_data, name.c_str(), out_data_len );
    RETURN( iBase_SUCCESS );
}

void iMesh_getTagType( iMesh_Instance instance,
                       /*in*/ const iBase_TagHandle tag_handle,
                       int* value_type,
                       int* err )
{
    DataType this_type;
    ErrorCode result = MOABI->tag_get_data_type( TAG_HANDLE( tag_handle ), this_type );CHKERR( result, "iMesh_getTagType: problem getting type." );

    if( this_type != MB_TYPE_HANDLE )
        *value_type = tstt_data_type_table[this_type];
    else if( MBIMESHI->is_set_handle_tag( TAG_HANDLE( tag_handle ) ) )
        *value_type = iBase_ENTITY_SET_HANDLE;
    else if( MBIMESHI->is_ent_handle_tag( TAG_HANDLE( tag_handle ) ) )
        *value_type = iBase_ENTITY_HANDLE;
    else
    {
        result = check_handle_tag_type( TAG_HANDLE( tag_handle ), MBIMESHI );CHKERR( result, "iMesh_getTagType: problem guessing handle tag subtype" );
        if( MBIMESHI->is_set_handle_tag( TAG_HANDLE( tag_handle ) ) )
            *value_type = iBase_ENTITY_SET_HANDLE;
        else
            *value_type = iBase_ENTITY_HANDLE;
    }

    RETURN( iBase_SUCCESS );
}

void iMesh_getTagSizeValues( iMesh_Instance instance,
                             /*in*/ const iBase_TagHandle tag_handle,
                             int* tag_size_val,
                             int* err )
{
    ErrorCode result = MOABI->tag_get_length( TAG_HANDLE( tag_handle ), *tag_size_val );CHKERR( result, "iMesh_getTagSize: problem getting size." );

    RETURN( iBase_SUCCESS );
}

void iMesh_getTagSizeBytes( iMesh_Instance instance,
                            /*in*/ const iBase_TagHandle tag_handle,
                            int* tag_size_bytes,
                            int* err )
{
    ErrorCode result = MOABI->tag_get_bytes( TAG_HANDLE( tag_handle ), *tag_size_bytes );CHKERR( result, "iMesh_getTagSize: problem getting size." );

    RETURN( iBase_SUCCESS );
}

void iMesh_getTagHandle( iMesh_Instance instance,
                         /*in*/ const char* tag_name,
                         iBase_TagHandle* tag_handle,
                         int* err,
                         const int tag_name_len )
{
    std::string tmp_tagname( tag_name, tag_name_len );
    eatwhitespace( tmp_tagname );

    ErrorCode result = MOABI->tag_get_handle( tmp_tagname.c_str(), 0, MB_TYPE_OPAQUE, (Tag&)*tag_handle, MB_TAG_ANY );

    if( MB_SUCCESS != result )
    {
        std::string msg( "iMesh_getTagHandle: problem getting handle for tag named '" );
        msg += std::string( tag_name ) + std::string( "'" );
        *tag_handle = 0;
        ERROR( result, msg.c_str() );
    }

    // do not return variable-length tags through ITAPS API
    int size;
    if( MB_SUCCESS != MOABI->tag_get_length( TAG_HANDLE( *tag_handle ), size ) ) RETURN( iBase_TAG_NOT_FOUND );

    RETURN( iBase_SUCCESS );
}

void iMesh_getAllIfaceTags( iMesh_Instance instance,
                            /*inout*/ iBase_TagHandle** tag_handles,
                            /*inout*/ int* tag_handles_allocated,
                            /*out*/ int* tag_handles_size,
                            int* err )
{
    std::vector< Tag > all_tags;

    ErrorCode result = MOABI->tag_get_tags( all_tags );CHKERR( result, "iMesh_getAllIfaceTags failed." );

    remove_var_len_tags( MOABI, all_tags );

    // now put those tag handles into sidl array
    ALLOC_CHECK_ARRAY_NOFAIL( tag_handles, all_tags.size() );
    memcpy( *tag_handles, &all_tags[0], all_tags.size() * sizeof( Tag ) );
    *tag_handles_size = all_tags.size();

    RETURN( iBase_SUCCESS );
}

void iMesh_setEntSetData( iMesh_Instance instance,
                          /*in*/ iBase_EntitySetHandle entity_set_handle,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*in*/ const void* tag_value,
                          /*in*/ const int,
                          int* err )
{
    ErrorCode result;

    EntityHandle set = ENTITY_HANDLE( entity_set_handle );
    result           = MOABI->tag_set_data( TAG_HANDLE( tag_handle ), &set, 1, tag_value );CHKERR( result, "iMesh_setEntSetData: error" );

    RETURN( iBase_SUCCESS );
}

void iMesh_setEntSetIntData( iMesh_Instance instance,
                             /*in*/ iBase_EntitySetHandle entity_set,
                             /*in*/ const iBase_TagHandle tag_handle,
                             /*in*/ const int tag_value,
                             int* err )
{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( int ), err );
}

void iMesh_setEntSetDblData( iMesh_Instance instance,
                             /*in*/ iBase_EntitySetHandle entity_set,
                             /*in*/ const iBase_TagHandle tag_handle,
                             /*in*/ const double tag_value,
                             int* err )
{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( double ), err );
}

void iMesh_setEntSetEHData( iMesh_Instance instance,
                            /*in*/ iBase_EntitySetHandle entity_set,
                            /*in*/ const iBase_TagHandle tag_handle,
                            /*in*/ const iBase_EntityHandle tag_value,
                            int* err )
{
    // XXX: decide how best to handle validating entity handles as tag data
    CHKNONEMPTY();
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( iBase_EntityHandle ), err );
}

void iMesh_setEntSetESHData( iMesh_Instance instance,
                             /*in*/ iBase_EntitySetHandle entity_set,
                             /*in*/ const iBase_TagHandle tag_handle,
                             /*in*/ const iBase_EntitySetHandle tag_value,
                             int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    iMesh_setEntSetData( instance, entity_set, tag_handle, &tag_value, sizeof( iBase_EntitySetHandle ), err );
}

void iMesh_getEntSetData( iMesh_Instance instance,
                          /*in*/ const iBase_EntitySetHandle entity_set_handle,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*inout*/ void* tag_value,
                          /*inout*/ int* tag_value_allocated,
                          /*inout*/ int* tag_value_size,
                          int* err )
{
    EntityHandle eh = ENTITY_HANDLE( entity_set_handle );
    Tag tag         = TAG_HANDLE( tag_handle );

    int tag_size;
    ErrorCode result = MOABI->tag_get_bytes( tag, tag_size );CHKERR( result, "iMesh_getEntSetData: couldn't get tag size." );

    ALLOC_CHECK_TAG_ARRAY( tag_value, tag_size );

    result = MOABI->tag_get_data( tag, &eh, 1, *static_cast< void** >( tag_value ) );

    CHKERR( result, "iMesh_getEntSetData didn't succeed." );
    KEEP_ARRAY( tag_value );
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntSetIntData( iMesh_Instance instance,
                             /*in*/ const iBase_EntitySetHandle entity_set,
                             /*in*/ const iBase_TagHandle tag_handle,
                             int* out_data,
                             int* err )
{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    void* tag_ptr = out_data;
    int dum_size  = sizeof( int );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &dum_size, &dum_size, err );
}

void iMesh_getEntSetDblData( iMesh_Instance instance,
                             /*in*/ const iBase_EntitySetHandle entity_set,
                             /*in*/ const iBase_TagHandle tag_handle,
                             double* out_data,
                             int* err )
{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    void* tag_ptr = out_data;
    int tag_size  = sizeof( double );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &tag_size, &tag_size, err );
}

void iMesh_getEntSetEHData( iMesh_Instance instance,
                            /*in*/ const iBase_EntitySetHandle entity_set,
                            /*in*/ const iBase_TagHandle tag_handle,
                            iBase_EntityHandle* out_data,
                            int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    void* tag_ptr = out_data;
    int tag_size  = sizeof( EntityHandle );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &tag_size, &tag_size, err );
}

void iMesh_getEntSetESHData( iMesh_Instance instance,
                             /*in*/ const iBase_EntitySetHandle entity_set,
                             /*in*/ const iBase_TagHandle tag_handle,
                             iBase_EntitySetHandle* out_data,
                             int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    void* tag_ptr = out_data;
    int tag_size  = sizeof( EntityHandle );
    iMesh_getEntSetData( instance, entity_set, tag_handle, &tag_ptr, &tag_size, &tag_size, err );
}

void iMesh_getAllEntSetTags( iMesh_Instance instance,
                             /*in*/ const iBase_EntitySetHandle entity_set_handle,
                             /*out*/ iBase_TagHandle** tag_handles,
                             /*out*/ int* tag_handles_allocated,
                             /*out*/ int* tag_handles_size,
                             int* err )
{
    EntityHandle eh = ENTITY_HANDLE( entity_set_handle );
    std::vector< Tag > all_tags;

    ErrorCode result = MOABI->tag_get_tags_on_entity( eh, all_tags );CHKERR( result, "iMesh_entitysetGetAllTagHandles failed." );

    remove_var_len_tags( MOABI, all_tags );

    // now put those tag handles into sidl array
    ALLOC_CHECK_ARRAY_NOFAIL( tag_handles, all_tags.size() );
    memcpy( *tag_handles, &all_tags[0], all_tags.size() * sizeof( Tag ) );

    *tag_handles_size = (int)all_tags.size();
    RETURN( iBase_SUCCESS );
}

void iMesh_rmvEntSetTag( iMesh_Instance instance,
                         /*in*/ iBase_EntitySetHandle entity_set_handle,
                         /*in*/ const iBase_TagHandle tag_handle,
                         int* err )
{
    EntityHandle set = ENTITY_HANDLE( entity_set_handle );
    ErrorCode result = MOABI->tag_delete_data( TAG_HANDLE( tag_handle ), &set, 1 );

    // don't return an error if the tag simply wasn't set on the ent set
    if( MB_TAG_NOT_FOUND == result )
        RETURN( iBase_SUCCESS );
    else
        RETURN( iBase_ERROR_MAP[result] );
}

void iMesh_setVtxCoord( iMesh_Instance instance,
                        /*in*/ iBase_EntityHandle vertex_handle,
                        /*in*/ const double x,
                        /*in*/ const double y,
                        /*in*/ const double z,
                        int* err )

{
    const double xyz[3] = { x, y, z };
    int geom_dim;
    MOABI->get_dimension( geom_dim );

    iMesh_setVtxArrCoords( instance, &vertex_handle, 1, iBase_BLOCKED, xyz, geom_dim, err );
}

void iMesh_createVtx( iMesh_Instance instance,
                      /*in*/ const double x,
                      /*in*/ const double y,
                      /*in*/ const double z,
                      /*out*/ iBase_EntityHandle* new_vertex_handle,
                      int* err )
{
    int dum             = 1;
    const double xyz[3] = { x, y, z };
    int geom_dim;
    MOABI->get_dimension( geom_dim );
    iMesh_createVtxArr( instance, 1, iBase_BLOCKED, xyz, geom_dim, &new_vertex_handle, &dum, &dum, err );
}

void iMesh_createEnt( iMesh_Instance instance,
                      /*in*/ const int new_entity_topology,
                      /*in*/ const iBase_EntityHandle* lower_order_entity_handles,
                      /*in*/ const int lower_order_entity_handles_size,
                      /*out*/ iBase_EntityHandle* new_entity_handle,
                      /*out*/ int* status,
                      int* err )
{
    if( 0 == lower_order_entity_handles_size )
    {
        ERROR( iBase_INVALID_ENTITY_COUNT, "iMesh_createEnt: need more than zero lower order entities." );
    }

    // call  directly to allow creation of higher-order entities
    // directly from connectivity
    EntityType this_type = mb_topology_table[new_entity_topology];
    EntityHandle tmp_ent;
    ErrorCode result = MOABI->create_element( this_type, CONST_HANDLE_ARRAY_PTR( lower_order_entity_handles ),
                                              lower_order_entity_handles_size, tmp_ent );
    if( MB_SUCCESS == result )
    {
        *new_entity_handle = reinterpret_cast< iBase_EntityHandle >( tmp_ent );
        *status            = iBase_NEW;

        if( MBIMESHI->AdjTable[5] || MBIMESHI->AdjTable[10] )
        {
            Range set_ents;
            set_ents.insert( tmp_ent );
            create_int_ents( MBIMESHI, set_ents );
        }

        RETURN( iBase_SUCCESS );
    }
    else
    {
        *new_entity_handle = 0;
        *status            = iBase_CREATION_FAILED;
        ERROR( result, "iMesh_createEnt: couldn't create entity" );
    }
}

void iMesh_deleteEnt( iMesh_Instance instance,
                      /*in*/ iBase_EntityHandle entity_handle,
                      int* err )
{
    iMesh_deleteEntArr( instance, &entity_handle, 1, err );
}

void iMesh_getArrData( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle* entity_handles,
                       /*in*/ const int entity_handles_size,
                       /*in*/ const iBase_TagHandle tag_handle,
                       /*inout*/ void* tag_values,
                       /*inout*/ int* tag_values_allocated,
                       /*out*/ int* tag_values_size,
                       int* err )
{
    if( 0 == entity_handles_size ) RETURN( iBase_SUCCESS );
    CHKNONEMPTY();

    const EntityHandle* ents = reinterpret_cast< const EntityHandle* >( entity_handles );
    Tag tag                  = TAG_HANDLE( tag_handle );

    int tag_size;
    ErrorCode result = MOABI->tag_get_bytes( tag, tag_size );
    if( MB_SUCCESS != result )
    {
        int nerr = -1;
        char tagn[64], msg[256];
        iMesh_getTagName( instance, tag_handle, tagn, &nerr, sizeof( tagn ) );
        snprintf( msg, sizeof( msg ), "iMesh_getArrData: couldn't get size for tag \"%s\"",
                  nerr == 0 ? tagn : "unknown" );
        ERROR( result, msg );
    }

    ALLOC_CHECK_TAG_ARRAY( tag_values, tag_size * entity_handles_size );

    result = MOABI->tag_get_data( tag, ents, entity_handles_size, *static_cast< void** >( tag_values ) );

    if( MB_SUCCESS != result )
    {
        std::string message( "iMesh_getArrData: " );
        if( MB_TAG_NOT_FOUND == result )
            message += "tag not found";
        else
            message += "failed";

        std::string name;
        if( MB_SUCCESS == MOABI->tag_get_name( tag, name ) )
        {
            message += "for tag \"";
            message += name;
            message += "\".";
        }
        ERROR( result, message.c_str() );
    }

    KEEP_ARRAY( tag_values );
    RETURN( iBase_SUCCESS );
}

void iMesh_getIntArrData( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*inout*/ int** tag_values,
                          /*inout*/ int* tag_values_allocated,
                          /*out*/ int* tag_values_size,
                          int* err )
{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    *tag_values_allocated *= sizeof( int );
    if( tag_values_size != tag_values_allocated ) *tag_values_size *= sizeof( int );
    iMesh_getArrData( instance, entity_handles, entity_handles_size, tag_handle, tag_values, tag_values_allocated,
                      tag_values_size, err );
    *tag_values_allocated /= sizeof( int );
    if( tag_values_size != tag_values_allocated ) *tag_values_size /= sizeof( int );
}

void iMesh_getDblArrData( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*inout*/ double** tag_values,
                          /*inout*/ int* tag_values_allocated,
                          /*out*/ int* tag_values_size,
                          int* err )
{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    *tag_values_allocated *= sizeof( double );
    if( tag_values_size != tag_values_allocated ) *tag_values_size *= sizeof( double );
    iMesh_getArrData( instance, entity_handles, entity_handles_size, tag_handle, tag_values, tag_values_allocated,
                      tag_values_size, err );
    *tag_values_allocated /= sizeof( double );
    if( tag_values_size != tag_values_allocated ) *tag_values_size /= sizeof( double );
}

void iMesh_getEHArrData( iMesh_Instance instance,
                         /*in*/ const iBase_EntityHandle* entity_handles,
                         /*in*/ const int entity_handles_size,
                         /*in*/ const iBase_TagHandle tag_handle,
                         /*inout*/ iBase_EntityHandle** tag_value,
                         /*inout*/ int* tag_value_allocated,
                         /*out*/ int* tag_value_size,
                         int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    *tag_value_allocated *= sizeof( iBase_EntityHandle );
    if( tag_value_size != tag_value_allocated ) *tag_value_size *= sizeof( iBase_EntityHandle );
    iMesh_getArrData( instance, entity_handles, entity_handles_size, tag_handle,
                      reinterpret_cast< void** >( tag_value ), tag_value_allocated, tag_value_size, err );
    *tag_value_allocated /= sizeof( iBase_EntityHandle );
    if( tag_value_size != tag_value_allocated ) *tag_value_size /= sizeof( iBase_EntityHandle );
}

void iMesh_getESHArrData( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*inout*/ iBase_EntitySetHandle** tag_value,
                          /*inout*/ int* tag_value_allocated,
                          /*out*/ int* tag_value_size,
                          int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    *tag_value_allocated *= sizeof( iBase_EntityHandle );
    if( tag_value_size != tag_value_allocated ) *tag_value_size *= sizeof( iBase_EntityHandle );
    iMesh_getArrData( instance, entity_handles, entity_handles_size, tag_handle,
                      reinterpret_cast< void** >( tag_value ), tag_value_allocated, tag_value_size, err );
    *tag_value_allocated /= sizeof( iBase_EntityHandle );
    if( tag_value_size != tag_value_allocated ) *tag_value_size /= sizeof( iBase_EntityHandle );
}

void iMesh_setArrData( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle* entity_handles,
                       /*in*/ const int entity_handles_size,
                       /*in*/ const iBase_TagHandle tag_handle,
                       /*in*/ const void* tag_values,
                       /*in*/ const int tag_values_size,
                       int* err )
{
    if( 0 == entity_handles_size ) RETURN( iBase_SUCCESS );
    CHKNONEMPTY();

    int tag_size;
    iMesh_getTagSizeBytes( instance, tag_handle, &tag_size, err );
    // Check err manually and just return if not iBase_SUCCESS to not step on
    // the error set in iMesh_getTagSizeBytes().
    if( iBase_SUCCESS != *err ) return;

    if( tag_values_size != ( tag_size * entity_handles_size ) )
    {
        ERROR( iBase_BAD_ARRAY_SIZE, "iMesh_setArrData: bad tag_values_size passed." );
    }

    ErrorCode result = MOABI->tag_set_data( TAG_HANDLE( tag_handle ), CONST_HANDLE_ARRAY_PTR( entity_handles ),
                                            entity_handles_size, tag_values );CHKERR( result, "iMesh_setArrData didn't succeed." );
    RETURN( iBase_SUCCESS );
}

void iMesh_setIntArrData( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*in*/ const int* tag_values,
                          /*in*/ const int tag_values_size,
                          int* err )
{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    iMesh_setArrData( instance, entity_handles, entity_handles_size, tag_handle,
                      reinterpret_cast< const char* >( tag_values ), sizeof( int ) * tag_values_size, err );
}

void iMesh_setDblArrData( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*in*/ const double* tag_values,
                          /*in*/ const int tag_values_size,
                          int* err )
{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    iMesh_setArrData( instance, entity_handles, entity_handles_size, tag_handle,
                      reinterpret_cast< const char* >( tag_values ), sizeof( double ) * tag_values_size, err );
}

void iMesh_setEHArrData( iMesh_Instance instance,
                         /*in*/ const iBase_EntityHandle* entity_handles,
                         /*in*/ const int entity_handles_size,
                         /*in*/ const iBase_TagHandle tag_handle,
                         /*in*/ const iBase_EntityHandle* tag_values,
                         /*in*/ const int tag_values_size,
                         int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    iMesh_setArrData( instance, entity_handles, entity_handles_size, tag_handle,
                      reinterpret_cast< const char* >( tag_values ), sizeof( iBase_EntityHandle ) * tag_values_size,
                      err );
}

void iMesh_setESHArrData( iMesh_Instance instance,
                          /*in*/ const iBase_EntityHandle* entity_handles,
                          /*in*/ const int entity_handles_size,
                          /*in*/ const iBase_TagHandle tag_handle,
                          /*in*/ const iBase_EntitySetHandle* tag_values,
                          /*in*/ const int tag_values_size,
                          int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    iMesh_setArrData( instance, entity_handles, entity_handles_size, tag_handle,
                      reinterpret_cast< const char* >( tag_values ), sizeof( iBase_EntityHandle ) * tag_values_size,
                      err );
}

void iMesh_rmvArrTag( iMesh_Instance instance,
                      /*in*/ const iBase_EntityHandle* entity_handles,
                      /*in*/ const int entity_handles_size,
                      /*in*/ const iBase_TagHandle tag_handle,
                      int* err )
{
    if( 0 == entity_handles_size ) RETURN( iBase_SUCCESS );
    CHKNONEMPTY();

    ErrorCode result = MOABI->tag_delete_data( TAG_HANDLE( tag_handle ), CONST_HANDLE_ARRAY_PTR( entity_handles ),
                                               entity_handles_size );

    // don't return an error if the tag simply wasn't set on the entities
    if( MB_TAG_NOT_FOUND == result )
        RETURN( iBase_SUCCESS );
    else
        RETURN( iBase_ERROR_MAP[result] );
}

void iMesh_getData( iMesh_Instance instance,
                    /*in*/ const iBase_EntityHandle entity_handle,
                    /*in*/ const iBase_TagHandle tag_handle,
                    /*out*/ void* tag_value,
                    /*inout*/ int* tag_value_allocated,
                    /*out*/ int* tag_value_size,
                    int* err )
{
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, tag_value, tag_value_allocated, tag_value_size, err );
}

void iMesh_getIntData( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle entity_handle,
                       /*in*/ const iBase_TagHandle tag_handle,
                       int* out_data,
                       int* err )
{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    void* val_ptr = out_data;
    int val_size  = sizeof( int );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &val_size, &val_size, err );
}

void iMesh_getDblData( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle entity_handle,
                       /*in*/ const iBase_TagHandle tag_handle,
                       double* out_data,
                       int* err )
{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    void* val_ptr = out_data;
    int val_size  = sizeof( double );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &val_size, &val_size, err );
}

void iMesh_getEHData( iMesh_Instance instance,
                      /*in*/ const iBase_EntityHandle entity_handle,
                      /*in*/ const iBase_TagHandle tag_handle,
                      iBase_EntityHandle* out_data,
                      int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    void* val_ptr = out_data;
    int dum       = sizeof( iBase_EntityHandle );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &dum, &dum, err );
}

void iMesh_getESHData( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle entity_handle,
                       /*in*/ const iBase_TagHandle tag_handle,
                       iBase_EntitySetHandle* out_data,
                       int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    void* val_ptr = out_data;
    int dum       = sizeof( iBase_EntityHandle );
    iMesh_getArrData( instance, &entity_handle, 1, tag_handle, &val_ptr, &dum, &dum, err );
}

void iMesh_setData( iMesh_Instance instance,
                    /*in*/ iBase_EntityHandle entity_handle,
                    /*in*/ const iBase_TagHandle tag_handle,
                    /*in*/ const void* tag_value,
                    /*in*/ const int tag_value_size,
                    int* err )
{
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, tag_value, tag_value_size, err );
}

void iMesh_setIntData( iMesh_Instance instance,
                       /*in*/ iBase_EntityHandle entity_handle,
                       /*in*/ const iBase_TagHandle tag_handle,
                       /*in*/ const int tag_value,
                       int* err )
{
    CHKTAGTYPE( tag_handle, iBase_INTEGER );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( int ), err );
}

void iMesh_setDblData( iMesh_Instance instance,

                       /*in*/ iBase_EntityHandle entity_handle,
                       /*in*/ const iBase_TagHandle tag_handle,
                       /*in*/ const double tag_value,
                       int* err )
{
    CHKTAGTYPE( tag_handle, iBase_DOUBLE );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( double ), err );
}

void iMesh_setEHData( iMesh_Instance instance,
                      /*in*/ iBase_EntityHandle entity_handle,
                      /*in*/ const iBase_TagHandle tag_handle,
                      /*in*/ const iBase_EntityHandle tag_value,
                      int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_HANDLE );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( iBase_EntityHandle ), err );
}

void iMesh_setESHData( iMesh_Instance instance,
                       /*in*/ iBase_EntityHandle entity_handle,
                       /*in*/ const iBase_TagHandle tag_handle,
                       /*in*/ const iBase_EntitySetHandle tag_value,
                       int* err )
{
    CHKTAGTYPE( tag_handle, iBase_ENTITY_SET_HANDLE );
    iMesh_setArrData( instance, &entity_handle, 1, tag_handle, reinterpret_cast< const char* >( &tag_value ),
                      sizeof( iBase_EntityHandle ), err );
}

void iMesh_getAllTags( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle entity_handle,
                       /*inout*/ iBase_TagHandle** tag_handles,
                       /*inout*/ int* tag_handles_allocated,
                       /*out*/ int* tag_handles_size,
                       int* err )
{
    std::vector< Tag > all_tags;

    ErrorCode result = MOABI->tag_get_tags_on_entity( ENTITY_HANDLE( entity_handle ), all_tags );CHKERR( result, "iMesh_getAllTags failed." );

    remove_var_len_tags( MOABI, all_tags );

    // now put those tag handles into sidl array
    ALLOC_CHECK_ARRAY_NOFAIL( tag_handles, all_tags.size() );
    memcpy( *tag_handles, &all_tags[0], all_tags.size() * sizeof( Tag ) );
    *tag_handles_size = all_tags.size();

    RETURN( iBase_SUCCESS );
}

void iMesh_rmvTag( iMesh_Instance instance,
                   /*in*/ iBase_EntityHandle entity_handle,
                   /*in*/ const iBase_TagHandle tag_handle,
                   int* err )
{
    iMesh_rmvArrTag( instance, &entity_handle, 1, tag_handle, err );
}

void iMesh_initEntIter( iMesh_Instance instance,
                        /*in*/ const iBase_EntitySetHandle entity_set_handle,
                        /*in*/ const int requested_entity_type,
                        /*in*/ const int requested_entity_topology,
                        /*in*/ const int resilient,
                        /*out*/ iBase_EntityIterator* entity_iterator,
                        int* err )
{
    iMesh_initEntArrIterRec( instance, entity_set_handle, requested_entity_type, requested_entity_topology, 1,
                             resilient, false, reinterpret_cast< iBase_EntityArrIterator* >( entity_iterator ), err );
}

void iMesh_getNextEntIter( iMesh_Instance instance,
                           /*in*/ iBase_EntityIterator entity_iterator,
                           /*out*/ iBase_EntityHandle* entity_handle,
                           int* is_end,
                           int* err )
{
    int eh_size = 1;
    iMesh_getNextEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( entity_iterator ), &entity_handle,
                             &eh_size, &eh_size, is_end, err );
}

void iMesh_resetEntIter( iMesh_Instance instance,
                         /*in*/ iBase_EntityIterator entity_iterator,
                         int* err )
{
    iMesh_resetEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( entity_iterator ), err );
}

void iMesh_endEntIter( iMesh_Instance instance,
                       /*in*/ iBase_EntityIterator entity_iterator,
                       int* err )
{
    iMesh_endEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( entity_iterator ), err );
}

void iMesh_getEntTopo( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle entity_handle,
                       int* out_topo,
                       int* err )
{
    *out_topo = tstt_topology_table[MOABI->type_from_handle( ENTITY_HANDLE( entity_handle ) )];
    RETURN( iBase_SUCCESS );
}

void iMesh_getEntType( iMesh_Instance instance,
                       /*in*/ const iBase_EntityHandle entity_handle,
                       int* out_type,
                       int* err )
{
    *out_type = tstt_type_table[MOABI->type_from_handle( ENTITY_HANDLE( entity_handle ) )];
    RETURN( iBase_SUCCESS );
}

void iMesh_getVtxCoord( iMesh_Instance instance,
                        /*in*/ const iBase_EntityHandle vertex_handle,
                        /*out*/ double* x,
                        /*out*/ double* y,
                        /*out*/ double* z,
                        int* err )
{
    int order     = iBase_BLOCKED;
    double xyz[3] = { 0 }, *tmp_xyz = xyz;
    int dum = 3;

    iMesh_getVtxArrCoords( instance, &vertex_handle, 1, order, &tmp_xyz, &dum, &dum, err );
    if( iBase_SUCCESS == *err )
    {
        *x = xyz[0];
        *y = xyz[1];
        *z = xyz[2];
    }
}

void iMesh_getEntAdj( iMesh_Instance instance,
                      /*in*/ const iBase_EntityHandle entity_handle,
                      /*in*/ const int entity_type_requested,
                      /*inout*/ iBase_EntityHandle** adj_entity_handles,
                      /*inout*/ int* adj_entity_handles_allocated,
                      /*out*/ int* adj_entity_handles_size,
                      int* err )
{
    int offsets[2];
    int* offsets_ptr = offsets;
    int offset_size, offset_allocated = 2;

    iMesh_getEntArrAdj( instance, &entity_handle, 1, entity_type_requested, adj_entity_handles,
                        adj_entity_handles_allocated, adj_entity_handles_size, &offsets_ptr, &offset_allocated,
                        &offset_size, err );
}

void iMesh_getEnt2ndAdj( iMesh_Instance instance,
                         iBase_EntityHandle entity_handle,
                         int order_adjacent_key,
                         int requested_entity_type,
                         iBase_EntityHandle** adj_entities,
                         int* adj_entities_allocated,
                         int* adj_entities_size,
                         int* err )
{
    int offsets[2];
    int* offsets_ptr = offsets;
    int offset_size, offset_allocated = 2;

    iMesh_getEntArr2ndAdj( instance, &entity_handle, 1, order_adjacent_key, requested_entity_type, adj_entities,
                           adj_entities_allocated, adj_entities_size, &offsets_ptr, &offset_allocated, &offset_size,
                           err );
}

void iMesh_subtract( iMesh_Instance instance,
                     /*in*/ const iBase_EntitySetHandle entity_set_1,
                     /*in*/ const iBase_EntitySetHandle entity_set_2,
                     /*out*/ iBase_EntitySetHandle* result_entity_set,
                     int* err )
{
    EntityHandle temp_set;
    EntityHandle set1 = ENTITY_HANDLE( entity_set_1 ), set2 = ENTITY_HANDLE( entity_set_2 );

    int isList1 = 0, isList2 = 0;
    iMesh_isList( instance, entity_set_1, &isList1, err );
    if( *err != iBase_SUCCESS ) return;
    iMesh_isList( instance, entity_set_2, &isList2, err );
    if( *err != iBase_SUCCESS ) return;

    ErrorCode result;
    if( isList1 && isList2 )
        result = MOABI->create_meshset( MESHSET_ORDERED, temp_set );
    else
        result = MOABI->create_meshset( MESHSET_SET, temp_set );

    if( MB_SUCCESS != result ) ERROR( result, "iMesh_subtract: couldn't create result set." );

    // if the second set is the root set, the result is always the empty set
    if( entity_set_2 )
    {
        if( !entity_set_1 )
        {
            // subtracting from the root set, so get everything first...
            Range entities;
            result = MOABI->get_entities_by_handle( 0, entities );
            if( MB_SUCCESS == result ) result = MOABI->add_entities( temp_set, entities );
            // ...but not the newly-created set!
            if( MB_SUCCESS == result ) result = MOABI->remove_entities( temp_set, &temp_set, 1 );
        }
        else
            result = MOABI->unite_meshset( temp_set, set1 );

        if( MB_SUCCESS == result ) result = MOABI->subtract_meshset( temp_set, set2 );
    }

    CHKERR( result, "iMesh_subtract: ERROR subtract failed." );
    *result_entity_set = (iBase_EntitySetHandle)temp_set;

    RETURN( iBase_SUCCESS );
}

void iMesh_intersect( iMesh_Instance instance,
                      /*in*/ const iBase_EntitySetHandle entity_set_1,
                      /*in*/ const iBase_EntitySetHandle entity_set_2,
                      /*out*/ iBase_EntitySetHandle* result_entity_set,
                      int* err )
{
    EntityHandle temp_set;
    EntityHandle set1 = ENTITY_HANDLE( entity_set_1 ), set2 = ENTITY_HANDLE( entity_set_2 );

    int isList1 = 0, isList2 = 0;
    iMesh_isList( instance, entity_set_1, &isList1, err );
    if( *err != iBase_SUCCESS ) return;
    iMesh_isList( instance, entity_set_2, &isList2, err );
    if( *err != iBase_SUCCESS ) return;

    ErrorCode result;
    if( isList1 && isList2 )
        result = MOABI->create_meshset( MESHSET_ORDERED, temp_set );
    else
        result = MOABI->create_meshset( MESHSET_SET, temp_set );

    if( MB_SUCCESS != result ) ERROR( result, "iMesh_intersect: couldn't create result set." );

    if( !entity_set_1 && !entity_set_2 )
    {
        // intersecting the root set with itself, so get everything...
        Range entities;
        result = MOABI->get_entities_by_handle( 0, entities );
        if( MB_SUCCESS == result ) result = MOABI->add_entities( temp_set, entities );
        // ...but not the newly-created set!
        if( MB_SUCCESS == result ) result = MOABI->remove_entities( temp_set, &temp_set, 1 );
    }
    else if( !entity_set_1 )
    {
        result = MOABI->unite_meshset( temp_set, set2 );
    }
    else if( !entity_set_2 )
    {
        result = MOABI->unite_meshset( temp_set, set1 );
    }
    else
    {
        if( isList1 && isList2 )
        {
            // ITAPS has very specific rules about the behavior of intersection on
            // list-type sets. Since MOAB doesn't (and likely will never) work
            // exactly this way, we implement our own algorithm here.

#ifdef MOAB_HAVE_UNORDERED_MAP
            typedef MOAB_UNORDERED_MAP_NS::unordered_map< EntityHandle, size_t > lookup_t;
#else
            typedef std::map< EntityHandle, size_t > lookup_t;
#endif

            // First, build a lookup table for the second set.
            lookup_t lookup;
            {
                std::vector< EntityHandle > contents2;
                result = MOABI->get_entities_by_handle( set2, contents2 );CHKERR( result, "iMesh_intersect: ERROR intersect failed." );

                for( std::vector< EntityHandle >::iterator i = contents2.begin(); i != contents2.end(); ++i )
                {
#ifdef MOAB_HAVE_UNORDERED_MAP
                    lookup_t::iterator j = lookup.find( *i );
#else
                    lookup_t::iterator j = lookup.lower_bound( *i );
#endif
                    if( j != lookup.end() && j->first == *i )
                        ++j->second;
                    else
                        lookup.insert( j, lookup_t::value_type( *i, 1 ) );
                }
            }

            // Then, iterate over the contents of the first set and check for
            // their existence in the second set.
            std::vector< EntityHandle > contents1;
            result = MOABI->get_entities_by_handle( set1, contents1 );CHKERR( result, "iMesh_intersect: ERROR intersect failed." );

            std::vector< EntityHandle >::iterator w = contents1.begin();
            for( std::vector< EntityHandle >::iterator i = contents1.begin(); i != contents1.end(); ++i )
            {
                lookup_t::iterator j = lookup.find( *i );
                if( j != lookup.end() && j->second )
                {
                    --j->second;
                    *w = *i;
                    ++w;
                }
            }

            result = MOABI->add_entities( temp_set, &contents1[0], w - contents1.begin() );
        }
        else
        {
            result = MOABI->unite_meshset( temp_set, set1 );
            if( MB_SUCCESS == result ) result = MOABI->intersect_meshset( temp_set, set2 );
        }
    }

    CHKERR( result, "iMesh_intersect: ERROR intersect failed." );
    *result_entity_set = (iBase_EntitySetHandle)temp_set;

    RETURN( iBase_SUCCESS );
}

void iMesh_unite( iMesh_Instance instance,
                  /*in*/ const iBase_EntitySetHandle entity_set_1,
                  /*in*/ const iBase_EntitySetHandle entity_set_2,
                  /*out*/ iBase_EntitySetHandle* result_entity_set,
                  int* err )
{
    EntityHandle temp_set;
    EntityHandle set1 = ENTITY_HANDLE( entity_set_1 ), set2 = ENTITY_HANDLE( entity_set_2 );

    int isList1 = 0, isList2 = 0;
    iMesh_isList( instance, entity_set_1, &isList1, err );
    if( *err != iBase_SUCCESS ) return;
    iMesh_isList( instance, entity_set_2, &isList2, err );
    if( *err != iBase_SUCCESS ) return;

    ErrorCode result;
    if( isList1 && isList2 )
        result = MOABI->create_meshset( MESHSET_ORDERED, temp_set );
    else
        result = MOABI->create_meshset( MESHSET_SET, temp_set );

    if( MB_SUCCESS != result ) ERROR( result, "iMesh_unite: couldn't create result set." );

    if( entity_set_1 && entity_set_2 )
    {
        result = MOABI->unite_meshset( temp_set, set1 );
        if( MB_SUCCESS == result ) result = MOABI->unite_meshset( temp_set, set2 );
    }
    else
    {
        // uniting with the root set, so get everything...
        Range entities;
        result = MOABI->get_entities_by_handle( 0, entities );
        if( MB_SUCCESS == result ) result = MOABI->add_entities( temp_set, entities );
        // ...but not the newly-created set!
        if( MB_SUCCESS == result ) result = MOABI->remove_entities( temp_set, &temp_set, 1 );
    }

    CHKERR( result, "iMesh_unite: ERROR unite failed." );

    *result_entity_set = (iBase_EntitySetHandle)temp_set;

    RETURN( iBase_SUCCESS );
}

void iMesh_getEntitiesRec( iMesh_Instance instance,
                           /*in*/ const iBase_EntitySetHandle entity_set_handle,
                           /*in*/ const int entity_type,
                           /*in*/ const int entity_topology,
                           /*in*/ const int recursive,
                           /*out*/ iBase_EntityHandle** entity_handles,
                           /*out*/ int* entity_handles_allocated,
                           /*out*/ int* entity_handles_size,
                           /*out*/ int* err )
{
    CHKENUM( entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );

    bool use_top = false;
    // initialize just to get rid of compiler warning
    EntityType type = mb_topology_table[iMesh_ALL_TOPOLOGIES];
    std::vector< EntityHandle > out_entities;

    if( entity_topology != iMesh_ALL_TOPOLOGIES )
    {
        type    = mb_topology_table[entity_topology];
        use_top = true;

        if( entity_type != iBase_ALL_TYPES )
        {
            if( entity_topology != iMesh_SEPTAHEDRON && entity_type != CN::Dimension( type ) )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );

            // Special-case handling for septahedra since we don't support them
            else if( entity_topology == iMesh_SEPTAHEDRON && entity_type != iBase_REGION )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );
        }
    }

    EntityHandle handle = ENTITY_HANDLE( entity_set_handle );
    ErrorCode result;

    if( use_top )
    {
        if( entity_topology == iMesh_SEPTAHEDRON )
            result = MB_SUCCESS;  // MOAB doesn't do septahedrons, so there are never any.
        else
            result = MOABI->get_entities_by_type( handle, type, out_entities, recursive );
    }
    else if( entity_type != iBase_ALL_TYPES )
        result = MOABI->get_entities_by_dimension( handle, entity_type, out_entities, recursive );
    else
        result = MOABI->get_entities_by_handle( handle, out_entities, recursive );

    CHKERR( result, "iMesh_GetEntities:ERROR getting entities." );

    // remove entity sets from the result list
    std::vector< EntityHandle >::iterator iter, end_iter;
    if( iBase_ALL_TYPES == entity_type && iMesh_ALL_TOPOLOGIES == entity_topology )
    {
        for( iter = out_entities.begin(); iter != out_entities.end() && TYPE_FROM_HANDLE( *iter ) != MBENTITYSET;
             ++iter )
            ;
        for( end_iter = iter; iter != out_entities.end(); ++iter )
            if( TYPE_FROM_HANDLE( *iter ) != MBENTITYSET ) *( end_iter++ ) = *iter;
        out_entities.erase( end_iter, out_entities.end() );
    }

    int num_ents = out_entities.size();

    ALLOC_CHECK_ARRAY_NOFAIL( entity_handles, num_ents );

    int k = 0;

    // filter out entity sets here
    for( iter = out_entities.begin(); iter != out_entities.end(); ++iter )
        ( *entity_handles )[k++] = (iBase_EntityHandle)*iter;

    // now it's safe to set the size; set it to k, not out_entities.size(), to
    // account for sets which might have been removed
    *entity_handles_size = k;

    RETURN( iBase_SUCCESS );
}

/**\brief  Get the number of entities with the specified type in the instance or set, recursive
 *
 * Get the number of entities with the specified type in the instance
 * or set.  If recursive is passed in non-zero, includes entities in owned sets.
 * If entity set handle is zero, return information for instance,
 * otherwise for set.  Value of entity type must be from the
 * iBase_EntityType enumeration.  If iBase_ALL_TYPES is specified,
 * total number of entities (excluding entity sets) is returned.
 * \param instance iMesh instance handle
 * \param entity_set_handle Entity set being queried
 * \param entity_type Type of entity requested
 * \param recursive If non-zero, includes entities in owned sets too
 * \param num_type Pointer to number of entities, returned from function
 * \param *err Pointer to error type returned from function
 */
void iMesh_getNumOfTypeRec( iMesh_Instance instance,
                            /*in*/ const iBase_EntitySetHandle entity_set_handle,
                            /*in*/ const int entity_type,
                            /*in*/ const int recursive,
                            /*out*/ int* num_type,
                            /*out*/ int* err )
{
    CHKENUM( entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );

    *num_type = 0;
    ErrorCode result;
    if( entity_type == iBase_ALL_TYPES )
    {
        result = MOABI->get_number_entities_by_handle( ENTITY_HANDLE( entity_set_handle ), *num_type, recursive );
        if( MB_SUCCESS == result && !recursive )
        {
            int num_sets = 0;
            result = MOABI->get_number_entities_by_type( ENTITY_HANDLE( entity_set_handle ), MBENTITYSET, num_sets,
                                                         recursive );
            *num_type -= num_sets;
        }
    }
    else
    {
        result = MOABI->get_number_entities_by_dimension( ENTITY_HANDLE( entity_set_handle ), entity_type, *num_type,
                                                          recursive );
    }

    CHKERR( result, "iMesh_entitysetGetNumberEntityOfType: "
                    "ERROR getting number of entities by type." );

    RETURN( iBase_SUCCESS );
}

/**\brief  Get the number of entities with the specified topology in the instance or set
 *
 * Get the number of entities with the specified topology in the instance
 * or set.  If recursive is passed in non-zero, includes entities in owned sets.
 * If entity set handle is zero, return information for instance,
 * otherwise for set.  Value of entity topology must be from the
 * iMesh_EntityTopology enumeration.  If iMesh_ALL_TOPOLOGIES is specified,
 * total number of entities (excluding entity sets) is returned.
 * \param instance iMesh instance handle
 * \param entity_set_handle Entity set being queried
 * \param entity_topology Topology of entity requested
 * \param recursive If non-zero, includes entities in owned sets too
 * \param num_topo Pointer to number of entities, returned from function
 * \param *err Pointer to error type returned from function
 */
void iMesh_getNumOfTopoRec( iMesh_Instance instance,
                            /*in*/ const iBase_EntitySetHandle entity_set_handle,
                            /*in*/ const int entity_topology,
                            /*in*/ const int recursive,
                            /*out*/ int* num_topo,
                            /*out*/ int* err )
{
    CHKENUM( entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );

    if( entity_topology == iMesh_SEPTAHEDRON )
    {
        *num_topo = 0;
        RETURN( iBase_SUCCESS );
    }

    *num_topo = 0;
    ErrorCode result;
    if( iMesh_ALL_TOPOLOGIES == entity_topology )
    {
        result = MOABI->get_number_entities_by_handle( ENTITY_HANDLE( entity_set_handle ), *num_topo, recursive );

        if( !recursive && MB_SUCCESS == result )
        {  // remove entity sets from count
            int num_sets;
            result = MOABI->get_number_entities_by_type( ENTITY_HANDLE( entity_set_handle ), MBENTITYSET, num_sets,
                                                         recursive );
            *num_topo -= num_sets;
        }
    }
    else
    {
        result = MOABI->get_number_entities_by_type( ENTITY_HANDLE( entity_set_handle ),
                                                     mb_topology_table[entity_topology], *num_topo, recursive );
    }

    CHKERR( result, "iMesh_entitysetGetNumberEntityOfTopology: ERROR getting "
                    "number of entities by topology." );
    RETURN( iBase_SUCCESS );
}

/**\brief  Get entities with specified type, topology, tag(s) and (optionally) tag value(s)
 *
 * Get entities with the specified type, topology, tag(s), and optionally tag value(s).
 * If tag values pointer is input as zero, entities with specified tag(s) are returned,
 * regardless of their value.
 * \param instance iMesh instance handle
 * \param entity_set_handle Entity set being queried
 * \param entity_type Type of entities being requested
 * \param entity_topology Topology of entities being requested
 * \param tag_handles Array of tag handles
 * \param tag_vals Array of tag values (zero if values not requested)
 * \param num_tags_vals Number of tags and optionally values
 * \param recursive If non-zero, gets entities in owned sets too
 * \param *entity_handles Pointer to array of entity handles returned
 *        from function
 * \param *entity_handles_allocated Pointer to allocated size of
 *        entity_handles array
 * \param *entity_handles_size Pointer to occupied size of entity_handles array
 * \param *err Pointer to error type returned from function
 */
void iMesh_getEntsByTagsRec( iMesh_Instance instance,
                             /*in*/ const iBase_EntitySetHandle entity_set_handle,
                             /*in*/ const int entity_type,
                             /*in*/ const int entity_topology,
                             /*in*/ const iBase_TagHandle* tag_handles,
                             /*in*/ const char* const* tag_vals,
                             /*in*/ const int num_tags_vals,
                             /*in*/ const int recursive,
                             /*out*/ iBase_EntityHandle** entity_handles,
                             /*out*/ int* entity_handles_allocated,
                             /*out*/ int* entity_handles_size,
                             /*out*/ int* err )
{
    CHKENUM( entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );

    bool use_top = false;
    // initialize just to get rid of compiler warning
    EntityType type = mb_topology_table[iMesh_ALL_TOPOLOGIES];
    Range out_entities;

    if( entity_topology != iMesh_ALL_TOPOLOGIES )
    {
        type    = mb_topology_table[entity_topology];
        use_top = true;

        if( entity_type != iBase_ALL_TYPES )
        {
            if( entity_topology != iMesh_SEPTAHEDRON && entity_type != CN::Dimension( type ) )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );

            // Special-case handling for septahedra since we don't support them
            else if( entity_topology == iMesh_SEPTAHEDRON && entity_type != iBase_REGION )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );
        }
    }

    EntityHandle handle = ENTITY_HANDLE( entity_set_handle );
    ErrorCode result    = MB_SUCCESS;

    if( use_top )
    {
        if( entity_topology == iMesh_SEPTAHEDRON )
            result = MB_SUCCESS;  // MOAB doesn't do septahedrons, so there are never any.
        else
            result =
                MOABI->get_entities_by_type_and_tag( handle, type, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                     num_tags_vals, out_entities, Interface::INTERSECT, recursive );
    }
    else if( entity_type != iBase_ALL_TYPES )
    {
        // need to loop over all types of this dimension
        DimensionPair dimpair = CN::getDimPair( entity_type );
        for( EntityType tp = dimpair.first; tp <= dimpair.second; tp++ )
        {
            Range tmp_range;
            ErrorCode tmp_result =
                MOABI->get_entities_by_type_and_tag( handle, type, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                     num_tags_vals, tmp_range, Interface::INTERSECT, recursive );
            if( MB_SUCCESS != tmp_result )
                result = tmp_result;
            else
                out_entities.merge( tmp_range );
        }
    }
    else
        result = MOABI->get_entities_by_type_and_tag( handle, type, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                      num_tags_vals, out_entities, Interface::INTERSECT, recursive );

    CHKERR( result, "iMesh_GetEntities:ERROR getting entities." );

    ALLOC_CHECK_ARRAY_NOFAIL( entity_handles, out_entities.size() );

    Range::iterator iter     = out_entities.begin();
    Range::iterator end_iter = out_entities.end();
    int k                    = 0;

    // filter out entity sets here
    if( iBase_ALL_TYPES == entity_type && iMesh_ALL_TOPOLOGIES == entity_topology )
    {
        for( ; iter != end_iter && MOABI->type_from_handle( *iter ) != MBENTITYSET; ++iter )
            ( *entity_handles )[k++] = (iBase_EntityHandle)*iter;
    }
    else
    {
        for( ; iter != end_iter; ++iter )
            ( *entity_handles )[k++] = (iBase_EntityHandle)*iter;
    }

    // now it's safe to set the size; set it to k, not out_entities.size(), to
    // account for sets which might have been removed
    *entity_handles_size = k;

    RETURN( iBase_SUCCESS );
}

void iMesh_getEntSetsByTagsRec( iMesh_Instance instance,
                                /*in*/ const iBase_EntitySetHandle entity_set_handle,
                                /*in*/ const iBase_TagHandle* tag_handles,
                                /*in*/ const char* const* tag_vals,
                                /*in*/ const int num_tags_vals,
                                /*in*/ const int recursive,
                                /*out*/ iBase_EntitySetHandle** set_handles,
                                /*out*/ int* set_handles_allocated,
                                /*out*/ int* set_handles_size,
                                /*out*/ int* err )
{
    Range out_entities;

    EntityHandle handle = ENTITY_HANDLE( entity_set_handle );
    ErrorCode result;

    result = MOABI->get_entities_by_type_and_tag( handle, MBENTITYSET, (Tag*)tag_handles, (const void* const*)tag_vals,
                                                  num_tags_vals, out_entities, Interface::INTERSECT, recursive );CHKERR( result, "ERROR getting entities." );

    ALLOC_CHECK_ARRAY_NOFAIL( set_handles, out_entities.size() );

    std::copy( out_entities.begin(), out_entities.end(), ( (EntityHandle*)*set_handles ) );

    RETURN( iBase_SUCCESS );
}

void iMesh_MBCNType( /*in*/ const int imesh_entity_topology,
                     /*out*/ int* mbcn_type )
{
    if( iMesh_POINT > imesh_entity_topology || iMesh_ALL_TOPOLOGIES <= imesh_entity_topology )
        *mbcn_type = -1;
    else
        *mbcn_type = mb_topology_table[imesh_entity_topology];
}

void iMesh_tagIterate( iMesh_Instance instance,
                       /*in*/ const iBase_TagHandle tag_handle,
                       iBase_EntityArrIterator entArr_iterator,
                       /**< [in] Iterator being queried */
                       void* data,
                       /**< [out] Pointer to pointer that will be set to tag data memory
                          \ref trio) */
                       int* count,
                       /**< [out] Number of contiguous entities in this subrange */
                       int* err
                       /**< [out] Returned Error status (see iBase_ErrorType) */
)
{
    MBRangeIter* ri = dynamic_cast< MBRangeIter* >( entArr_iterator );
    if( !ri ) CHKERR( MB_FAILURE, "Wrong type of iterator, need a range-based iterator for iMesh_tagIterate." );

    ErrorCode result = MOABI->tag_iterate( TAG_HANDLE( tag_handle ), ri->position(), ri->end(), *count,
                                           *static_cast< void** >( data ) );CHKERR( result, "Problem getting tag iterator." );

    RETURN( iBase_SUCCESS );
}

void iMesh_connectIterate( iMesh_Instance instance,
                           iBase_EntityArrIterator entArr_iterator,
                           /**< [in] Iterator being queried */
                           iBase_EntityHandle** connect,
                           /**< [out] Pointer to pointer that will be set to connectivity data memory */
                           int* verts_per_entity,
                           /**< [out] Pointer to integer set to number of vertices per entity */
                           int* count,
                           /**< [out] Number of contiguous entities in this subrange */
                           int* err
                           /**< [out] Returned Error status (see iBase_ErrorType) */
)
{
    MBRangeIter* ri = dynamic_cast< MBRangeIter* >( entArr_iterator );
    if( !ri ) CHKERR( MB_FAILURE, "Wrong type of iterator, need a range-based iterator for iMesh_connectIterate." );

    ErrorCode result =
        MOABI->connect_iterate( ri->position(), ri->end(), reinterpret_cast< EntityHandle*& >( *connect ),
                                *verts_per_entity, *count );CHKERR( result, "Problem getting connect iterator." );

    RETURN( iBase_SUCCESS );
}

void iMesh_coordsIterate( iMesh_Instance instance,
                          iBase_EntityArrIterator entArr_iterator,
                          /**< [in] Iterator being queried */
                          double** xcoords_ptr,
                          /**< [out] Pointer to pointer that will be set to x coordinate data memory */
                          double** ycoords_ptr,
                          /**< [out] Pointer to pointer that will be set to y coordinate data memory */
                          double** zcoords_ptr,
                          /**< [out] Pointer to pointer that will be set to z coordinate data memory */
                          int* count,
                          /**< [out] Number of contiguous entities in this subrange */
                          int* err
                          /**< [out] Returned Error status (see iBase_ErrorType) */
)
{
    MBRangeIter* ri = dynamic_cast< MBRangeIter* >( entArr_iterator );
    if( !ri ) CHKERR( MB_FAILURE, "Wrong type of iterator, need a range-based iterator for iMesh_coordsIterate." );

    ErrorCode result =
        MOABI->coords_iterate( ri->position(), ri->end(), *xcoords_ptr, *ycoords_ptr, *zcoords_ptr, *count );CHKERR( result, "Problem getting coords iterator." );

    RETURN( iBase_SUCCESS );
}

void iMesh_stepEntIter( iMesh_Instance instance,
                        /**< [in] iMesh instance handle */
                        iBase_EntityIterator ent_iterator,
                        /**< [in] Iterator being queried */
                        int step_length,
                        /**< [in] Number of entities to step the iterator */
                        int* at_end,
                        /**< [out] Non-zero if iterator is at the end of the iteration */
                        int* err
                        /**< [out] Returned Error status (see iBase_ErrorType) */
)
{
    iMesh_stepEntArrIter( instance, reinterpret_cast< iBase_EntityArrIterator >( ent_iterator ), step_length, at_end,
                          err );
}

void iMesh_stepEntArrIter( iMesh_Instance instance,
                           /**< [in] iMesh instance handle */
                           iBase_EntityArrIterator entArr_iterator,
                           /**< [in] Iterator being queried */
                           int step_length,
                           /**< [in] Number of entities to step the iterator */
                           int* at_end,
                           /**< [out] Non-zero if iterator is at the end of the iteration */
                           int* err
                           /**< [out] Returned Error status (see iBase_ErrorType) */
)
{
    bool tmp;
    ErrorCode result = entArr_iterator->step( step_length, tmp );CHKERR( result, "Problem stepping iterator." );
    *at_end = tmp;
    RETURN( iBase_SUCCESS );
}

/**
 * Method:  initEntArrIter[]
 */
void iMesh_initEntArrIterRec( iMesh_Instance instance,
                              /*in*/ const iBase_EntitySetHandle entity_set_handle,
                              /*in*/ const int requested_entity_type,
                              /*in*/ const int requested_entity_topology,
                              /*in*/ const int requested_array_size,
                              /*in*/ const int resilient,
                              /*in*/ const int recursive,
                              /*out*/ iBase_EntityArrIterator* entArr_iterator,
                              int* err )
{
    CHKENUM( requested_entity_type, iBase_EntityType, iBase_INVALID_ENTITY_TYPE );
    CHKENUM( requested_entity_topology, iMesh_EntityTopology, iBase_INVALID_ENTITY_TOPOLOGY );
    if( resilient ) ERROR( iBase_NOT_SUPPORTED, "reslient iterators not supported" );

    EntityType req_type = mb_topology_table[requested_entity_topology];

    if( requested_entity_topology != iMesh_ALL_TOPOLOGIES )
    {
        if( requested_entity_type != iBase_ALL_TYPES )
        {
            if( requested_entity_topology != iMesh_SEPTAHEDRON && requested_entity_type != CN::Dimension( req_type ) )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );

            // Special-case handling for septahedra since we don't support them
            else if( requested_entity_topology == iMesh_SEPTAHEDRON && requested_entity_type != iBase_REGION )
                ERROR( iBase_BAD_TYPE_AND_TOPO, "type and topology are inconsistant" );
        }
    }

    ErrorCode result;
    unsigned flags;
    result = MOABI->get_meshset_options( ENTITY_HANDLE( entity_set_handle ), flags );CHKERR( result, "Invalid entity set handle" );

    if( flags & MESHSET_ORDERED )
        *entArr_iterator =
            new MBListIter( (iBase_EntityType)requested_entity_type, (iMesh_EntityTopology)requested_entity_topology,
                            ENTITY_HANDLE( entity_set_handle ), requested_array_size, recursive );
    else
        *entArr_iterator =
            new MBRangeIter( (iBase_EntityType)requested_entity_type, (iMesh_EntityTopology)requested_entity_topology,
                             ENTITY_HANDLE( entity_set_handle ), requested_array_size, recursive );
    result = ( *entArr_iterator )->reset( MOABI );
    if( MB_SUCCESS != result ) delete *entArr_iterator;CHKERR( result, "iMesh_initEntArrIter: ERROR getting entities of proper type or topology." );
    RETURN( iBase_SUCCESS );
}

void iMesh_createTagWithOptions( iMesh_Instance instance,
                                 /*in*/ const char* tag_name,
                                 /*in*/ const char* tmp_tag_options,
                                 /*in*/ const int tag_size,
                                 /*in*/ const int tag_type,
                                 /*out*/ iBase_TagHandle* tag_handle,
                                 /*out*/ int* err,
                                 /*in*/ const int tag_name_len,
                                 /*in*/ const int tag_options_len )
{
    if( tag_size < 0 ) ERROR( iBase_INVALID_ARGUMENT, "iMesh_createTag: invalid tag size" );
    CHKENUM( tag_type, iBase_TagValueType, iBase_INVALID_ARGUMENT );

    std::string tmp_tagname( tag_name, tag_name_len );
    eatwhitespace( tmp_tagname );

    moab::TagType storage = MB_TAG_SPARSE;
    ErrorCode result;

    // declared here 'cuz might have to hold destination of a default value ptr
    std::string storage_type;
    const void* def_val = NULL;
    std::vector< int > def_int;
    std::vector< double > def_dbl;
    std::vector< moab::EntityHandle > def_handles;
    int dum_int;
    double dum_dbl;

    if( 0 != tag_options_len )
    {
        std::string tag_options = filter_options( tmp_tag_options, tmp_tag_options + tag_options_len );
        FileOptions opts( tag_options.c_str() );
        const char* option_vals[]       = { "SPARSE", "DENSE", "BIT", "MESH" };
        const moab::TagType opt_types[] = { moab::MB_TAG_SPARSE, moab::MB_TAG_DENSE, moab::MB_TAG_BIT,
                                            moab::MB_TAG_MESH };
        int opt_num                     = -1;
        result                          = opts.match_option( "TAG_STORAGE_TYPE", option_vals, opt_num );
        if( MB_FAILURE == result )
            ERROR( result, "iMesh_createTagWithOptions: option string not recognized." );
        else if( MB_SUCCESS == result )
        {
            assert( opt_num >= 0 && opt_num <= 3 );
            storage = opt_types[opt_num];
        }

        // now look for default value option; reuse storage_type
        storage_type.clear();
        result = opts.get_option( "TAG_DEFAULT_VALUE", storage_type );
        if( MB_SUCCESS == result )
        {
            // ok, need to parse the string into a proper default value
            switch( tag_type )
            {
                case iBase_INTEGER:
                    result = opts.get_int_option( "TAG_DEFAULT_VALUE", dum_int );
                    def_int.resize( tag_size );
                    std::fill( def_int.begin(), def_int.end(), dum_int );
                    def_val = &def_int[0];
                    break;
                case iBase_DOUBLE:
                    result = opts.get_real_option( "TAG_DEFAULT_VALUE", dum_dbl );
                    def_dbl.resize( tag_size );
                    std::fill( def_dbl.begin(), def_dbl.end(), dum_dbl );
                    def_val = &def_dbl[0];
                    break;
                case iBase_ENTITY_HANDLE:
                    // for default handle, will have to use int
                    result = opts.get_int_option( "TAG_DEFAULT_VALUE", dum_int );
                    if( 0 > dum_int )
                        ERROR( result, "iMesh_createTagWithOptions: for default handle-type tag, "
                                       "must use non-negative int on input." );
                    def_handles.resize( tag_size );
                    std::fill( def_handles.begin(), def_handles.end(), (moab::EntityHandle)dum_int );
                    def_val = &def_handles[0];
                    break;
                case iBase_BYTES:
                    if( (int)storage_type.length() < tag_size )
                        ERROR( result, "iMesh_createTagWithOptions: default value for byte-type "
                                       "tag must be large enough to store tag value." );
                    def_val = storage_type.c_str();
                    break;
            }
        }
    }

    moab::Tag new_tag;
    result = MOABI->tag_get_handle( tmp_tagname.c_str(), tag_size, mb_data_type_table[tag_type], new_tag,
                                    storage | MB_TAG_EXCL, def_val );

    if( MB_SUCCESS != result )
    {
        std::string msg( "iMesh_createTag: " );
        if( MB_ALREADY_ALLOCATED == result )
        {
            msg += "Tag already exists with name: \"";
            *tag_handle = (iBase_TagHandle)new_tag;
        }
        else
            msg += "Failed to create tag with name: \"";
        msg += tag_name;
        msg += "\".";
        ERROR( result, msg.c_str() );
    }

    if( tag_type == iBase_ENTITY_HANDLE )
        MBIMESHI->note_ent_handle_tag( new_tag );
    else if( tag_type == iBase_ENTITY_SET_HANDLE )
        MBIMESHI->note_set_handle_tag( new_tag );

    *tag_handle = (iBase_TagHandle)new_tag;

    RETURN( iBase_SUCCESS );

    /* old implementation:
       Tag new_tag;
       int this_size = tag_size;

       ErrorCode result = MOABI->tag_get_handle(tmp_tagname.c_str(),
       this_size,
       mb_data_type_table[tag_type],
       new_tag,
       MB_TAG_SPARSE|MB_TAG_EXCL);

       if (MB_SUCCESS != result) {
       std::string msg("iMesh_createTag: ");
       if (MB_ALREADY_ALLOCATED == result) {
       msg += "Tag already exists with name: \"";
       *tag_handle = (iBase_TagHandle) new_tag;
       }
       else
       msg += "Failed to create tag with name: \"";
       msg += tag_name;
       msg += "\".";
       ERROR(result,msg.c_str());
       }

       if (tag_type == iBase_ENTITY_HANDLE)
       MBIMESHI->note_ent_handle_tag( new_tag );
       else if (tag_type == iBase_ENTITY_SET_HANDLE)
       MBIMESHI->note_set_handle_tag( new_tag );

       *tag_handle = (iBase_TagHandle) new_tag;
       */
}

#ifdef __cplusplus
}  // extern "C"
#endif

ErrorCode create_int_ents( MBiMesh* mbimesh, Range& from_ents, const EntityHandle* in_set )
{
    // MBiMesh* mbimesh = dynamic_cast(instance);
    assert( mbimesh );
    assert( mbimesh->AdjTable[10] || mbimesh->AdjTable[5] );
    Range int_ents;
    ErrorCode result;
    Interface* instance = mbimesh->mbImpl;
    if( mbimesh->AdjTable[10] )
    {
        result = instance->get_adjacencies( from_ents, 2, true, int_ents, Interface::UNION );
        if( MB_SUCCESS != result ) return result;
        unsigned int old_size = from_ents.size();
        from_ents.merge( int_ents );
        if( old_size != from_ents.size() && in_set )
        {
            result = instance->add_entities( *in_set, int_ents );
            if( MB_SUCCESS != result ) return result;
        }
    }

    if( mbimesh->AdjTable[5] )
    {
        int_ents.clear();
        result = instance->get_adjacencies( from_ents, 1, true, int_ents, Interface::UNION );
        if( MB_SUCCESS != result ) return result;
        unsigned int old_size = from_ents.size();
        from_ents.merge( int_ents );
        if( old_size != from_ents.size() && in_set )
        {
            result = instance->add_entities( *in_set, int_ents );
            if( MB_SUCCESS != result ) return result;
        }
    }

    return MB_SUCCESS;
}

void eatwhitespace( std::string& this_string )
{
    std::string::size_type p = this_string.find_last_not_of( " " );
    if( p != this_string.npos ) this_string.resize( p + 1 );
}

void iMesh_createStructuredMesh( iMesh_Instance instance,
                                 /*in*/ int* local_dims,
                                 /*in*/ int* global_dims,
                                 /*in*/ double* i_vals,
                                 /*in*/ double* j_vals,
                                 /*in*/ double* k_vals,
                                 /*in*/ int resolve_shared,
                                 /*in*/ int ghost_dim,
                                 /*in*/ int bridge_dim,
                                 /*in*/ int num_layers,
                                 /*in*/ int addl_ents,
                                 /*in*/ int vert_gids,
                                 /*in*/ int elem_gids,
                                 /*inout*/ iBase_EntitySetHandle* set_handle,
                                 /*out*/ int* err )
{
    ScdInterface* scdi = NULL;
    ErrorCode rval     = MOABI->query_interface( scdi );CHKERR( rval, "Couldn't get structured mesh interface." );

    Range tmp_range;
    ScdBox* scd_box;
    rval =
        scdi->construct_box( HomCoord( local_dims[0], local_dims[1], ( -1 != local_dims[2] ? local_dims[2] : 0 ), 1 ),
                             HomCoord( local_dims[3], local_dims[4], ( -1 != local_dims[5] ? local_dims[5] : 0 ), 1 ),
                             NULL, 0, scd_box, NULL, NULL, ( vert_gids ? true : false ) );CHKERR( rval, "Trouble creating scd vertex sequence." );

    // set the global box parameters
    if( global_dims )
    {
        for( int i = 0; i < 6; i++ )
            scd_box->par_data().gDims[i] = global_dims[i];
    }

    tmp_range.insert( scd_box->start_vertex(), scd_box->start_vertex() + scd_box->num_vertices() - 1 );
    tmp_range.insert( scd_box->start_element(), scd_box->start_element() + scd_box->num_elements() - 1 );
    tmp_range.insert( scd_box->box_set() );

    if( set_handle )
    {
        if( !( *set_handle ) )
        {
            // return the new ScdBox's set
            *set_handle = reinterpret_cast< iBase_EntitySetHandle >( scd_box->box_set() );
        }
        else
        {
            // add the new ScdBox's set to the given file set
            EntityHandle s = scd_box->box_set();
            rval           = MOABI->add_entities( ENTITY_HANDLE( *set_handle ), &s, 1 );CHKERR( rval, "Couldn't add box set to file set." );
        }
    }

    // get a ptr to global id memory
    void* data;
    int count;
    Range::const_iterator topv, bote, tope;

    Tag gid_tag     = 0;
    int *v_gid_data = NULL, *e_gid_data = NULL;
    if( vert_gids || elem_gids )
    {
        gid_tag = MOABI->globalId_tag();
    }

    if( vert_gids )
    {
        topv = tmp_range.upper_bound( tmp_range.begin(), tmp_range.end(),
                                      scd_box->start_vertex() + scd_box->num_vertices() );

        rval = MOABI->tag_iterate( gid_tag, tmp_range.begin(), topv, count, data );CHKERR( rval, "Failed to get tag iterator." );
        assert( count == scd_box->num_vertices() );
        v_gid_data = (int*)data;
    }

    if( elem_gids )
    {
        bote = tmp_range.lower_bound( tmp_range.begin(), tmp_range.end(), scd_box->start_element() );
        tope = tmp_range.upper_bound( tmp_range.begin(), tmp_range.end(), *bote + scd_box->num_elements() );

        rval = MOABI->tag_iterate( gid_tag, bote, tope, count, data );CHKERR( rval, "Failed to get tag iterator." );
        assert( count == scd_box->num_elements() );
        e_gid_data = (int*)data;
    }

    if( i_vals || j_vals || k_vals || v_gid_data || e_gid_data )
    {

        // set the vertex coordinates
        double *xc, *yc, *zc;
        rval = scd_box->get_coordinate_arrays( xc, yc, zc );CHKERR( rval, "Couldn't get vertex coordinate arrays." );

        int i, j, k, il, jl, kl;
        int dil = local_dims[3] - local_dims[0] + 1;
        int djl = local_dims[4] - local_dims[1] + 1;
        int di  = ( global_dims ? global_dims[3] - global_dims[0] + 1 : dil );
        int dj  = ( global_dims ? global_dims[4] - global_dims[1] + 1 : djl );
        for( kl = local_dims[2]; kl <= local_dims[5]; kl++ )
        {
            k = kl - local_dims[2];
            for( jl = local_dims[1]; jl <= local_dims[4]; jl++ )
            {
                j = jl - local_dims[1];
                for( il = local_dims[0]; il <= local_dims[3]; il++ )
                {
                    i                = il - local_dims[0];
                    unsigned int pos = i + j * dil + k * dil * djl;
                    xc[pos]          = ( i_vals ? i_vals[i] : -1.0 );
                    yc[pos]          = ( j_vals ? j_vals[j] : -1.0 );
                    zc[pos]          = ( -1 == local_dims[2] ? 0.0 : ( k_vals ? k_vals[k] : -1.0 ) );
                    if( v_gid_data )
                    {
                        *v_gid_data = ( -1 != kl ? kl * di * dj : 0 ) + jl * di + il + 1;
                        v_gid_data++;
                    }
                    if( e_gid_data && kl < local_dims[5] && jl < local_dims[4] && il < local_dims[3] )
                    {
                        *e_gid_data = ( -1 != kl ? kl * ( di - 1 ) * ( dj - 1 ) : 0 ) + jl * ( di - 1 ) + il + 1;
                        e_gid_data++;
                    }
                }
            }
        }
    }

#ifdef MOAB_HAVE_MPI
    // do parallel stuff, if requested
    if( resolve_shared )
    {
        ParallelComm* pcomm = ParallelComm::get_pcomm( MOABI, 0 );
        if( pcomm )
        {

            rval =
                pcomm->resolve_shared_ents( 0, MOABI->dimension_from_handle( scd_box->start_element() ), 0, &gid_tag );CHKERR( rval, "Trouble resolving shared vertices." );

            if( -1 != ghost_dim )
            {
                rval = pcomm->exchange_ghost_cells( ghost_dim, bridge_dim, num_layers, addl_ents, true );CHKERR( rval, "Trouble exchanging ghosts." );
            }
        }
    }
#else
    // empty statement to remove compiler warning
    if( resolve_shared || ghost_dim || bridge_dim || num_layers || addl_ents )
    {
    }
#endif

    RETURN( iBase_SUCCESS );
}

void iMesh_freeMemory( iMesh_Instance /*instance*/,
                       /**< [in] iMesh instance handle */
                       void** ptrToMem )
{
    free( *ptrToMem );
    *ptrToMem = 0;
    return;
}