file-desc.c File Reference

#include "mhdf.h"
#include "util.h"
#include "status.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <H5Tpublic.h>
#include <H5Dpublic.h>
#include <H5Ppublic.h>

Include dependency graph for file-desc.c:

Go to the source code of this file.

Macros
#define	FIX_OFFSET(TYPE, FIELD)

Functions
static struct mhdf_FileDesc *	alloc_file_desc (mhdf_Status *status)
static void *	realloc_data (struct mhdf_FileDesc **data, size_t append_bytes, mhdf_Status *status, int alignment)
void	mhdf_fixFileDesc (struct mhdf_FileDesc *copy_ptr, const struct mhdf_FileDesc *orig_addr)
	Fix nested pointers for copied/moved FileDesc struct. More...
static struct mhdf_FileDesc *	get_elem_desc (mhdf_FileHandle file_handle, struct mhdf_FileDesc *result, const char *elem_handle, int idx, mhdf_Status *status)
static unsigned	get_file_id_size (hid_t file_id_type, mhdf_Status *status)
static struct mhdf_FileDesc *	get_tag_desc (mhdf_FileHandle file_handle, struct mhdf_FileDesc *result, const char *name, int idx, hid_t type, mhdf_Status *status)
static void	free_string_list (char **list, int count)
struct mhdf_FileDesc *	mhdf_getFileSummary (mhdf_FileHandle file_handle, hid_t file_id_type, mhdf_Status *status, int extraSetInfo)
	Get summary of data tables contained within file. More...

Variables
static char	buffer [512]

Macro Definition Documentation

FIX_OFFSET

#define FIX_OFFSET	(		TYPE,
			FIELD
	)

Value:

    if( copy_ptr->FIELD != NULL ) \
    copy_ptr->FIELD = (TYPE)( ( (char*)( copy_ptr->FIELD ) - (char*)orig_addr ) + (char*)copy_ptr )

Definition at line 73 of file file-desc.c.

Function Documentation

alloc_file_desc()

static struct mhdf_FileDesc * alloc_file_desc ( mhdf_Status *  status )

static

Definition at line 15 of file file-desc.c.

{
    struct mhdf_FileDesc* result;
    /* allocate a little short of a page */
    result = (struct mhdf_FileDesc*)mhdf_malloc( 4000, status );
    if( mhdf_isError( status ) ) return 0;
 
    memset( result, 0, sizeof( struct mhdf_FileDesc ) );
    result->total_size = 4000;
    result->offset     = ( (unsigned char*)result ) + sizeof( struct mhdf_FileDesc );
    return result;
}

References mhdf_isError(), mhdf_malloc(), mhdf_FileDesc::offset, and mhdf_FileDesc::total_size.

Referenced by mhdf_getFileSummary().

free_string_list()

static void free_string_list ( char **  list, int  count  )

static

Definition at line 377 of file file-desc.c.

{
    int i;
    for( i = 0; i < count; ++i )
        free( list[i] );
    free( list );
}

Referenced by mhdf_getFileSummary().

get_elem_desc()

static struct mhdf_FileDesc* get_elem_desc ( mhdf_FileHandle  file_handle, struct mhdf_FileDesc *  result, const char *  elem_handle, int  idx, mhdf_Status *  status  )

static

Definition at line 120 of file file-desc.c.

{
    hid_t id_pair[2];
    int poly;
    void* ptr;
    long junk;
 
    ptr = realloc_data( &result, strlen( elem_handle ) + 1, status, sizeof( char ) );
    if( !ptr ) return NULL;
    strcpy( ptr, elem_handle );
    result->elems[idx].handle = ptr;
 
    mhdf_getElemTypeName( file_handle, elem_handle, buffer, sizeof( buffer ), status );
    if( mhdf_isError( status ) )
    {
        free( result );
        return NULL;
    }
 
    ptr = realloc_data( &result, strlen( buffer ) + 1, status, sizeof( char ) );
    if( !ptr ) return NULL;
    strcpy( ptr, buffer );
    result->elems[idx].type = ptr;
 
    poly = mhdf_isPolyElement( file_handle, elem_handle, status );
    if( mhdf_isError( status ) )
    {
        free( result );
        return NULL;
    }
 
    if( !poly )
    {
        id_pair[0] = mhdf_openConnectivity( file_handle, elem_handle, &result->elems[idx].desc.vals_per_ent,
                                            &result->elems[idx].desc.count, &result->elems[idx].desc.start_id, status );
        if( id_pair[0] < 0 )
        {
            free( result );
            return NULL;
        }
        mhdf_closeData( file_handle, id_pair[0], status );
    }
    else
    {
        result->elems[idx].desc.vals_per_ent = -1;
        mhdf_openPolyConnectivity( file_handle, elem_handle, &result->elems[idx].desc.count, &junk,
                                   &result->elems[idx].desc.start_id, id_pair, status );
        if( id_pair[0] < 0 )
        {
            free( result );
            return NULL;
        }
        mhdf_closeData( file_handle, id_pair[0], status );
        mhdf_closeData( file_handle, id_pair[1], status );
    }
 
    result->elems[idx].desc.dense_tag_indices = NULL;
    result->elems[idx].desc.num_dense_tags    = 0;
    result->elems[idx].have_adj               = mhdf_haveAdjacency( file_handle, result->elems[idx].handle, status );
    if( mhdf_isError( status ) )
    {
        free( result );
        return 0;
    }
 
    return result;
}

References buffer, mhdf_EntDesc::count, mhdf_EntDesc::dense_tag_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, mhdf_ElemDesc::handle, mhdf_ElemDesc::have_adj, mhdf_closeData(), mhdf_getElemTypeName(), mhdf_haveAdjacency(), mhdf_isError(), mhdf_isPolyElement(), mhdf_openConnectivity(), mhdf_openPolyConnectivity(), mhdf_EntDesc::num_dense_tags, realloc_data(), mhdf_EntDesc::start_id, mhdf_ElemDesc::type, and mhdf_EntDesc::vals_per_ent.

Referenced by mhdf_getFileSummary().

get_file_id_size()

static unsigned get_file_id_size ( hid_t  file_id_type, mhdf_Status *  status  )

static

Definition at line 192 of file file-desc.c.

{
    if( H5Tget_class( file_id_type ) != H5T_INTEGER )
    {
        mhdf_setFail( status, "Invalid handle or type class for file ID type." );
        return 0;
    }
 
    return H5Tget_size( file_id_type );
}

References mhdf_setFail().

Referenced by get_tag_desc().

get_tag_desc()

static struct mhdf_FileDesc* get_tag_desc ( mhdf_FileHandle  file_handle, struct mhdf_FileDesc *  result, const char *  name, int  idx, hid_t  type, mhdf_Status *  status  )

static

Definition at line 203 of file file-desc.c.

{
    void* ptr;
    int have_default, have_global;
    int valsize, size, close_type = 0;
    hsize_t array_len;
 
    ptr = realloc_data( &result, strlen( name ) + 1, status, sizeof( char ) );
    if( NULL == ptr ) return NULL;
    strcpy( ptr, name );
    result->tags[idx].name = ptr;
 
    mhdf_getTagInfo( file_handle, name, &result->tags[idx].type, &result->tags[idx].size, &result->tags[idx].storage,
                     &have_default, &have_global, &result->tags[idx].have_sparse, status );
    if( mhdf_isError( status ) )
    {
        free( result );
        return NULL;
    }
 
    /* For variable length tags, have_default and have_global will
       contain the size of the respective values.  For fixed-length
       tags, they are either zero or one.  Simplify later code by
       making them contain the size for both cases. */
    valsize = result->tags[idx].size;
    if( result->tags[idx].size >= 0 )
    {
        if( have_default ) have_default = valsize;
        if( have_global ) have_global = valsize;
    }
 
    result->tags[idx].default_value      = NULL;
    result->tags[idx].default_value_size = have_default;
    result->tags[idx].global_value       = NULL;
    result->tags[idx].global_value_size  = have_global;
 
    switch( result->tags[idx].type )
    {
        case mhdf_OPAQUE:
            type = 0;
            break;
        case mhdf_BOOLEAN:
            type = H5T_NATIVE_UCHAR;
            break;
        case mhdf_INTEGER:
            type = H5T_NATIVE_INT;
            have_default *= sizeof( int );
            have_global *= sizeof( int );
            valsize *= sizeof( int );
            break;
        case mhdf_FLOAT:
            type = H5T_NATIVE_DOUBLE;
            have_default *= sizeof( double );
            have_global *= sizeof( double );
            valsize *= sizeof( double );
            break;
        case mhdf_BITFIELD:
            have_default = ( have_default + 7 ) / 8;
            have_global  = ( have_global + 7 ) / 8;
            valsize      = ( valsize + 7 ) / 8;
            switch( valsize )
            {
                case 1:
                    type = H5Tcopy( H5T_NATIVE_B8 );
                    break;
                case 2:
                    type = H5Tcopy( H5T_NATIVE_B16 );
                    break;
                case 3:
                case 4:
                    valsize += 4 - valsize;  // to avoid fallthrough warning
                    type = H5Tcopy( H5T_NATIVE_B32 );
                    break;
                case 5:
                case 6:
                case 7:
                case 8:
                    valsize += 8 - valsize;  // to avoid fallthrough warning
                    type = H5Tcopy( H5T_NATIVE_B64 );
                    break;
                default:
                    free( result );
                    mhdf_setFail( status, "Cannot create a bit tag larger than 64-bits.  %d bits requested.\n",
                                  (int)valsize );
                    return NULL;
            }
            close_type = 1;
            break;
        case mhdf_ENTITY_ID:
            if( 0 == type ) type = H5T_NATIVE_ULONG;
            size = get_file_id_size( type, status );
            if( !size )
            {
                free( result );
                return NULL;
            }
            have_default *= size;
            have_global *= size;
            valsize *= size;
            break;
        default:
            mhdf_setFail( status, "Unknown mhdf_TagDataType value (%d) for tag (\"%s\")", (int)result->tags[idx].type,
                          name );
            free( result );
            return NULL;
    }
    result->tags[idx].bytes = valsize;
 
    if( result->tags[idx].type != mhdf_OPAQUE && result->tags[idx].type != mhdf_BITFIELD && result->tags[idx].size > 1 )
    {
        close_type = 1;
        array_len  = result->tags[idx].size;
#if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
        type = H5Tarray_create2( type, 1, &array_len );
#else
        type = H5Tarray_create( type, 1, &array_len, 0 );
#endif
        if( type < 0 )
        {
            mhdf_setFail( status, "H5Tarray_create failed for tag (\"%s\")", name );
            free( result );
            return NULL;
        }
    }
 
    if( have_default || have_global )
    {
        if( have_default )
        {
            ptr = realloc_data( &result, have_default, status, sizeof( int ) );
            if( NULL == ptr )
            {
                if( close_type )
                {
                    H5Tclose( type );
                }
                return NULL;
            }
            result->tags[idx].default_value = ptr;
        }
        if( have_global )
        {
            ptr = realloc_data( &result, have_global, status, sizeof( int ) );
            if( NULL == ptr )
            {
                if( close_type )
                {
                    H5Tclose( type );
                }
                return NULL;
            }
            result->tags[idx].global_value = ptr;
        }
        mhdf_getTagValues( file_handle, name, type, result->tags[idx].default_value, result->tags[idx].global_value,
                           status );
        if( close_type )
        {
            H5Tclose( type );
        }
        if( mhdf_isError( status ) )
        {
            free( result );
            return NULL;
        }
    }
 
    return result;
}

References mhdf_TagDesc::bytes, mhdf_TagDesc::default_value, mhdf_TagDesc::default_value_size, get_file_id_size(), mhdf_TagDesc::global_value, mhdf_TagDesc::global_value_size, mhdf_TagDesc::have_sparse, mhdf_BITFIELD, mhdf_BOOLEAN, mhdf_ENTITY_ID, mhdf_FLOAT, mhdf_getTagInfo(), mhdf_getTagValues(), mhdf_INTEGER, mhdf_isError(), mhdf_OPAQUE, mhdf_setFail(), mhdf_TagDesc::name, realloc_data(), mhdf_TagDesc::size, size, mhdf_TagDesc::storage, mhdf_FileDesc::tags, and mhdf_TagDesc::type.

Referenced by mhdf_getFileSummary().

mhdf_fixFileDesc()

void mhdf_fixFileDesc	(	struct mhdf_FileDesc *	copy_ptr,
		const struct mhdf_FileDesc *	orig_addr
	)

Fix nested pointers for copied/moved FileDesc struct.

This is a utility method to facility copying/moving/communicating struct FileDesc instances. The structure and all data it references are allocated in a single contiguous block of memory of size FileDesc::total_size. As such, the struct can be copied with a single memcpy, packed into a single network packet, communicated with a single MPI call, etc. However, the pointers contained within the struct will not be valid in the copied instance (they will still point into the original instance.) Given a pointer to the copied struct and the address of the original struct, this function will updated all contained pointers.

Definition at line 77 of file file-desc.c.

{
    int i;
 
    API_BEGIN;
    FIX_OFFSET( int*, nodes.dense_tag_indices );
    FIX_OFFSET( int*, sets.dense_tag_indices );
    FIX_OFFSET( struct mhdf_ElemDesc*, elems );
    FIX_OFFSET( struct mhdf_TagDesc*, tags );
 
    FIX_OFFSET( int*, numEntSets );
    FIX_OFFSET( int**, defTagsEntSets );
    FIX_OFFSET( int**, defTagsVals );
 
    for( i = 0; i < 5; i++ )
    {
        if( copy_ptr->defTagsEntSets ) FIX_OFFSET( int*, defTagsEntSets[i] );
        if( copy_ptr->defTagsVals ) FIX_OFFSET( int*, defTagsVals[i] );
    }
 
    if( copy_ptr->elems != NULL )
    {
        for( i = 0; i < copy_ptr->num_elem_desc; ++i )
        {
            FIX_OFFSET( const char*, elems[i].handle );
            FIX_OFFSET( const char*, elems[i].type );
            FIX_OFFSET( int*, elems[i].desc.dense_tag_indices );
        }
    }
 
    if( copy_ptr->tags != NULL )
    {
        for( i = 0; i < copy_ptr->num_tag_desc; ++i )
        {
            FIX_OFFSET( const char*, tags[i].name );
            FIX_OFFSET( void*, tags[i].default_value );
            FIX_OFFSET( void*, tags[i].global_value );
            FIX_OFFSET( int*, tags[i].dense_elem_indices );
        }
    }
    API_END;
}

References API_BEGIN, API_END, mhdf_FileDesc::defTagsEntSets, mhdf_FileDesc::defTagsVals, mhdf_EntDesc::dense_tag_indices, mhdf_FileDesc::elems, FIX_OFFSET, mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::num_tag_desc, mhdf_FileDesc::numEntSets, mhdf_FileDesc::sets, and mhdf_FileDesc::tags.

Referenced by realloc_data(), and moab::ReadHDF5::set_up_read().

mhdf_getFileSummary()

struct mhdf_FileDesc* mhdf_getFileSummary	(	mhdf_FileHandle	file_handle,
		hid_t	file_id_type,
		mhdf_Status *	status,
		int	extraSetInfo
	)

Get summary of data tables contained within file.

Returned struct, including all pointed-to data, is allocated in a single contiguous block of memory with a size equal to 'total_size'. Caller is responsible for freeing the returned struct FileDesc pointer (and only that pointer, not pointers nexted within the struct!). Caller may copy (e.g. MPI_BCast) entire struct as one contiguous block, assuming all nested pointers in the copy are updated to the correct relative offset from the beginning of the struct.

Definition at line 385 of file file-desc.c.

{
    struct mhdf_FileDesc* result;
    hid_t table_id;
    int i, i1, numtags, j, k, size, *indices, have, num_tag_names = 0;
    unsigned int ui;
    void* ptr;
    char **elem_handles = 0, **tag_names = 0;
    unsigned char *array, *matrix;
    const char* pname[5] = { "PARALLEL_PARTITION", "MATERIAL_SET", "NEUMANN_SET", "DIRICHLET_SET", "GEOM_DIMENSION" };
 
    long* id_list;
    struct mhdf_TagDesc* tag_desc;
    long int nval, junk;
    hid_t table[3];
    hid_t data_type;
 
    API_BEGIN;
 
    mhdf_setOkay( status );
    result = alloc_file_desc( status );
    if( NULL == result ) return NULL;
 
    /* get node info */
    have = mhdf_haveNodes( file_handle, status );
    if( mhdf_isError( status ) )
    {
        free( result );
        return NULL;
    }
    if( have )
    {
        table_id = mhdf_openNodeCoords( file_handle, &result->nodes.count, &result->nodes.vals_per_ent,
                                        &result->nodes.start_id, status );
        if( table_id < 0 )
        {
            free( result );
            return NULL;
        }
        mhdf_closeData( file_handle, table_id, status );
    }
    else
    {
        result->nodes.count        = 0;
        result->nodes.vals_per_ent = 0;
        result->nodes.start_id     = 0;
    }
 
    /* get set info */
    result->sets.vals_per_ent = -1;
    have                      = mhdf_haveSets( file_handle, &result->have_set_contents, &result->have_set_children,
                                               &result->have_set_parents, status );
    if( mhdf_isError( status ) )
    {
        free( result );
        return NULL;
    }
    if( have )
    {
        table_id = mhdf_openSetMeta( file_handle, &result->sets.count, &result->sets.start_id, status );
        if( table_id < 0 )
        {
            free( result );
            return NULL;
        }
        mhdf_closeData( file_handle, table_id, status );
    }
    else
    {
        result->sets.count    = 0;
        result->sets.start_id = 0;
    }
 
    /* get element list */
    elem_handles = mhdf_getElemHandles( file_handle, &ui, status );
    if( elem_handles == NULL )
    {
        free( result );
        return NULL;
    }
    result->num_elem_desc = ui;
 
    /* allocate array of element descriptors */
    size = result->num_elem_desc * sizeof( struct mhdf_ElemDesc );
    ptr  = realloc_data( &result, size, status, sizeof( char* ) );
    if( NULL == ptr )
    {
        free( elem_handles );
        return NULL;
    }
    memset( ptr, 0, size );
    result->elems = ptr;
 
    /* Initialize each element descriptor */
    for( i = 0; i < result->num_elem_desc; ++i )
    {
        result = get_elem_desc( file_handle, result, elem_handles[i], i, status );
        if( NULL == result )
        {
            free( elem_handles );
            return NULL;
        }
    }
 
    /* get tag list */
    tag_names = mhdf_getTagNames( file_handle, &num_tag_names, status );
    if( mhdf_isError( status ) )
    {
        free( elem_handles );
        free( result );
        return NULL;
    }
 
    /* allocate array of tag descriptors */
    size = num_tag_names * sizeof( struct mhdf_TagDesc );
    ptr  = realloc_data( &result, size, status, sizeof( char* ) );
    if( NULL == ptr )
    {
        free( elem_handles );
        free_string_list( tag_names, result->num_tag_desc );
        return NULL;
    }
    memset( ptr, 0, size );
    result->tags         = ptr;
    result->num_tag_desc = num_tag_names;
    memset( result->tags, 0, size );
 
    /* Initialize each tag descriptor */
    for( i = 0; i < result->num_tag_desc; ++i )
    {
        result = get_tag_desc( file_handle, result, tag_names[i], i, file_id_type, status );
        if( NULL == result )
        {
            free( elem_handles );
            free_string_list( tag_names, num_tag_names );
            return NULL;
        }
    }
 
    /* Determine which dense tags are present */
 
    size  = ( 2 + result->num_elem_desc ) * result->num_tag_desc;
    array = mhdf_malloc( size, status );
    if( NULL == array )
    {
        free( elem_handles );
        free_string_list( tag_names, num_tag_names );
        free( result );
        return NULL;
    }
    memset( array, 0, size );
    matrix = array + ( 2 * result->num_tag_desc );
 
    for( j = 0; j < result->num_tag_desc; ++j )
    {
        if( mhdf_haveDenseTag( file_handle, tag_names[j], mhdf_node_type_handle(), status ) )
            matrix[-1 * result->num_tag_desc + j] = 1;
        if( mhdf_haveDenseTag( file_handle, tag_names[j], mhdf_set_type_handle(), status ) )
            matrix[-2 * result->num_tag_desc + j] = 1;
        for( i = 0; i < result->num_elem_desc; ++i )
            if( mhdf_haveDenseTag( file_handle, tag_names[j], elem_handles[i], status ) )
                matrix[i * result->num_tag_desc + j] = 1;
    }
    free( elem_handles );
    free_string_list( tag_names, result->num_tag_desc );
 
    /* Populate dense tag lists for element types */
    for( i = -2; i < result->num_elem_desc; ++i )
    {
        size = 0;
        for( j = 0; j < result->num_tag_desc; ++j )
            size += matrix[i * result->num_tag_desc + j];
        if( !size )
        {
            indices = NULL;
        }
        else
        {
            indices = realloc_data( &result, size * sizeof( int ), status, sizeof( int ) );
            if( NULL == indices )
            {
                free( array );
                return NULL;
            }
 
            k = 0;
            for( j = 0; j < result->num_tag_desc; ++j )
                if( matrix[i * result->num_tag_desc + j] ) indices[k++] = j;
            assert( k == size );
        }
 
        if( i == -2 )
        {
            result->sets.dense_tag_indices = indices;
            result->sets.num_dense_tags    = size;
        }
        else if( i == -1 )
        {
            result->nodes.dense_tag_indices = indices;
            result->nodes.num_dense_tags    = size;
        }
        else
        {
            result->elems[i].desc.dense_tag_indices = indices;
            result->elems[i].desc.num_dense_tags    = size;
        }
    }
 
    /* Populate dense tag lists for each tag */
    for( j = 0; j < result->num_tag_desc; ++j )
    {
        size = 0;
        for( i = -2; i < result->num_elem_desc; ++i )
            size += matrix[i * result->num_tag_desc + j];
        if( !size )
        {
            indices = 0;
        }
        else
        {
            indices = realloc_data( &result, size * sizeof( int ), status, sizeof( int ) );
            if( NULL == ptr )
            {
                free( array );
                return NULL;
            }
 
            k = 0;
            for( i = -2; i < result->num_elem_desc; ++i )
                if( matrix[i * result->num_tag_desc + j] ) indices[k++] = i;
            assert( k == size );
        }
 
        result->tags[j].num_dense_indices  = size;
        result->tags[j].dense_elem_indices = indices;
    }
 
    if( extraSetInfo )
    {
        /* open the table for parallel partitions, material sets, neumann sets,
         * dirichlet sets
         *  to determine number of parts, etc
         *   this is needed for iMOAB and VisIt plugin */
        const int NPRIMARY_SETS = 5;
        ptr                     = realloc_data( &result, NPRIMARY_SETS * sizeof( int ), status, sizeof( int ) );
        if( NULL == ptr || mhdf_isError( status ) )
        {
            free( array );
            return NULL;
        }
        result->numEntSets = ptr;
        for( i = 0; i < NPRIMARY_SETS; ++i )
            result->numEntSets[i] = 0;
 
        ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int* ), status, sizeof( int* ) );
        if( NULL == ptr || mhdf_isError( status ) )
        {
            free( array );
            return NULL;
        }
        result->defTagsEntSets = ptr;
 
        ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int* ), status, sizeof( int* ) );
        if( NULL == ptr || mhdf_isError( status ) )
        {
            free( array );
            return NULL;
        }
        result->defTagsVals = ptr;
        numtags             = result->num_tag_desc;
 
        for( i = 0; i < numtags; i++ )
        {
            tag_desc = &( result->tags[i] );
            for( k = 0; k < NPRIMARY_SETS; k++ ) /* number of default tags to consider */
            {
                if( strcmp( pname[k], tag_desc->name ) == 0 )
                {
                    if( tag_desc->have_sparse )
                    {
                        mhdf_openSparseTagData( file_handle, pname[k], &nval, &junk, table, status );
                        if( mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        /* for sparse tags, read */
                        result->numEntSets[k] = nval;
                        if( nval <= 0 ) continue; /* do not do anything */
 
                        ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
                        if( NULL == ptr || mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        memset( ptr, 0, nval * sizeof( int ) );
                        result->defTagsEntSets[k] = ptr;
                        tag_desc                  = &( result->tags[i] );
 
                        ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
                        if( NULL == ptr || mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        memset( ptr, 0, nval * sizeof( int ) );
                        result->defTagsVals[k] = ptr;
                        tag_desc               = &( result->tags[i] ); /* this is because the tag might point to
                                                              something else*/
 
                        /* make room for the long array type
                          is it long or something else? */
                        id_list = mhdf_malloc( nval * sizeof( long ), status );
                        /* fill the id with values, then convert to int type (-set start)
 
                         mhdf_read_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT,
                         status );*/
 
                        data_type = H5Dget_type( table[0] );
 
                        mhdf_read_data( table[0], 0, nval, data_type, id_list, H5P_DEFAULT, status );
                        if( mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        H5Tclose( data_type );
 
                        for( i1 = 0; i1 < nval; i1++ )
                            result->defTagsEntSets[k][i1] = (int)( id_list[i1] - result->sets.start_id + 1 );
                        /* now read values, integer type */
                        data_type = H5Dget_type( table[1] );
                        mhdf_read_data( table[1], 0, nval, data_type, result->defTagsVals[k], H5P_DEFAULT, status );
                        if( mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        H5Tclose( data_type );
                        mhdf_closeData( file_handle, table[0], status );
                        if( mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        mhdf_closeData( file_handle, table[1], status );
                        if( mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        free( id_list );
                    }
                    else if( 0 == k || 1 == k )
                    { /* parallel partition or material sets should still work if dense
 could be dense tags on sets */
                        if( !mhdf_haveDenseTag( file_handle, pname[k], mhdf_set_type_handle(), status ) ) continue;
                        table[0] =
                            mhdf_openDenseTagData( file_handle, pname[k], mhdf_set_type_handle(), &nval, status );
                        if( mhdf_isError( status ) )
                        {
                            continue; /* do not error out if not a dense tag either */
                        }
                        result->numEntSets[k] = nval;
                        if( nval <= 0 ) continue; /* do not do anything */
 
                        /*
                         * if dense parallel partition or material set, we know what to expect
                         */
                        result->numEntSets[k] = nval; /* k could be 0 or 1 */
                        if( nval <= 0 ) continue;     /* do not do anything */
 
                        ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
                        if( NULL == ptr || mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        memset( ptr, 0, nval * sizeof( int ) );
                        result->defTagsEntSets[k] = ptr;
                        tag_desc                  = &( result->tags[i] );
 
                        ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
                        if( NULL == ptr || mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        memset( ptr, 0, nval * sizeof( int ) );
                        result->defTagsVals[k] = ptr;
                        tag_desc               = &( result->tags[i] ); /* this is because the tag might point to
                                                              something else*/
 
                        for( i1 = 0; i1 < nval; i1++ )
                        {
                            result->defTagsEntSets[k][i1] = i1 + 1;
                            /*result -> defTagsVals[k][i1] = i1; we know how the partition looks
                             * like  */
                        }
                        /* fill in the data with the dense tag values
                          because dense, sets will be in order
 
                          we know it has to be integer */
                        mhdf_readTagValues( table[0], 0, nval, H5T_NATIVE_INT, result->defTagsVals[k], status );
                        if( mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                        mhdf_closeData( file_handle, table[0], status );
                        if( mhdf_isError( status ) )
                        {
                            free( array );
                            return NULL;
                        }
                    }
                }
            }
        }
    }
    /* Compact memory and return */
    free( array );
    result->total_size = result->offset - (unsigned char*)result;
 
    API_END;
    return result;
}

References alloc_file_desc(), API_BEGIN, API_END, mhdf_EntDesc::count, mhdf_FileDesc::defTagsEntSets, mhdf_FileDesc::defTagsVals, mhdf_TagDesc::dense_elem_indices, mhdf_EntDesc::dense_tag_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, free_string_list(), get_elem_desc(), get_tag_desc(), mhdf_FileDesc::have_set_children, mhdf_FileDesc::have_set_contents, mhdf_FileDesc::have_set_parents, mhdf_TagDesc::have_sparse, mhdf_closeData(), mhdf_getElemHandles(), mhdf_getTagNames(), mhdf_haveDenseTag(), mhdf_haveNodes(), mhdf_haveSets(), mhdf_isError(), mhdf_malloc(), mhdf_node_type_handle(), mhdf_openDenseTagData(), mhdf_openNodeCoords(), mhdf_openSetMeta(), mhdf_openSparseTagData(), mhdf_read_data(), mhdf_readTagValues(), mhdf_set_type_handle(), mhdf_setOkay(), mhdf_TagDesc::name, mhdf_FileDesc::nodes, mhdf_TagDesc::num_dense_indices, mhdf_EntDesc::num_dense_tags, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::num_tag_desc, mhdf_FileDesc::numEntSets, mhdf_FileDesc::offset, realloc_data(), mhdf_FileDesc::sets, size, mhdf_EntDesc::start_id, mhdf_FileDesc::tags, mhdf_FileDesc::total_size, and mhdf_EntDesc::vals_per_ent.

Referenced by iMOAB_ReadHeaderInfo(), main(), and moab::ReadHDF5::set_up_read().

realloc_data()

static void * realloc_data ( struct mhdf_FileDesc **  data, size_t  append_bytes, mhdf_Status *  status, int  alignment  )

static

Definition at line 28 of file file-desc.c.

{
    void* result_ptr;
    struct mhdf_FileDesc* const input_ptr = *data;
    unsigned char* mem_ptr                = (unsigned char*)input_ptr;
 
    size_t new_size, occupied_size = input_ptr->offset - mem_ptr;
 
    size_t append_bytes_padded = append_bytes + alignment - 1;
    /* if the end of the allocated space is before the end of the required space */
    if( mem_ptr + input_ptr->total_size < input_ptr->offset + append_bytes_padded )
    {
        if( append_bytes_padded < input_ptr->total_size )
            new_size = 2 * input_ptr->total_size;
        else
            new_size = input_ptr->total_size + append_bytes_padded;
        *data = (struct mhdf_FileDesc*)mhdf_realloc( *data, new_size, status );
        if( mhdf_isError( status ) ) return 0;
 
        /* if realloc moved us to a different location in memory,
         * we need to update all of the internal pointers to
         * new locations relative to the start of the struct */
        if( *data != input_ptr )
        {
            mhdf_fixFileDesc( *data, input_ptr );
            mem_ptr           = (unsigned char*)( *data );
            ( *data )->offset = mem_ptr + occupied_size;
        }
        ( *data )->total_size = new_size;
    }
 
    result_ptr = ( *data )->offset;
    /* need to make this return pointer aligned */
    uintptr_t addr = (uintptr_t)( ( *data )->offset );
    int pad        = addr % alignment;
    if( pad > 0 )
    {
        ( *data )->offset += ( alignment - pad );
        result_ptr = ( *data )->offset;
    }
    /*printf("new address %p \n", result_ptr);*/
    ( *data )->offset += append_bytes;
    return result_ptr;
}

References mhdf_fixFileDesc(), mhdf_isError(), mhdf_realloc(), mhdf_FileDesc::offset, and mhdf_FileDesc::total_size.

Referenced by get_elem_desc(), get_tag_desc(), and mhdf_getFileSummary().

Variable Documentation

buffer

char buffer[512]

static

Definition at line 13 of file file-desc.c.

Referenced by moab::WriteHDF5Parallel::append_serial_tag_data(), moab::WriteHDF5Parallel::check_serial_tag_data(), check_valid_adjacencies(), check_valid_elem_conn(), check_valid_poly_conn(), moab::convert_to_ranged_ids(), file_exists(), get_elem_desc(), moab::ReadHDF5::get_tagged_entities(), moab::INT_IO_ERROR(), moab::mem_to_string(), mhdf_getElemHandles(), mhdf_getElemName(), mhdf_getElemTypeName(), mhdf_name_to_path_cat(), mhdf_name_to_path_copy(), moab::mpi_err_str(), moab::WriteHDF5::ExportSet::name(), moab::WriteHDF5Parallel::pack_set(), print_iGeom_error(), print_iMesh_error(), moab::print_range(), moab::DebugOutput::print_real(), moab::ErrorOutput::print_real(), moab::ReadHDF5Dataset::read(), moab::ReadHDF5::read_adjacencies(), moab::ReadHDF5::read_elems(), moab::ReadHDF5::read_node_adj_elems(), moab::ReadHDF5::read_nodes(), moab::ReadHDF5VarLen::read_offsets(), moab::ReadHDF5::read_poly(), moab::ReadHDF5::read_set_data(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::read_var_len_tag(), moab::ParCommGraph::receive_mesh(), moab::ParCommGraph::receive_tag_values(), moab::ReorderTool::reorder_tag_data(), moab::ReadHDF5::search_tag_values(), moab::ParCommGraph::send_graph_partition(), moab::ParCommGraph::send_mesh_parts(), moab::ParCommGraph::send_tag_values(), moab::ReadHDF5::store_file_ids(), moab::ReadHDF5::store_sets_file_ids(), string_tag_value(), moab::DebugOutput::tprint_real(), moab::WriteHDF5Parallel::unpack_set(), moab::WriteHDF5::write_adjacencies(), moab::WriteHDF5::write_elems(), moab::WriteHDF5::write_nodes(), moab::WriteHDF5::write_set_data(), moab::WriteHDF5::write_sets(), and moab::WriteHDF5::write_var_len_data().