tags.c File Reference

#include <stdlib.h>
#include <string.h>
#include <H5Tpublic.h>
#include <H5Gpublic.h>
#include <H5Dpublic.h>
#include <H5Spublic.h>
#include <H5Apublic.h>
#include <H5Ppublic.h>
#include "status.h"
#include "file-handle.h"
#include "mhdf.h"
#include "util.h"
#include "names-and-paths.h"

Include dependency graph for tags.c:

Go to the source code of this file.

Functions
hid_t	mhdf_getNativeType (hid_t input_type, int size, mhdf_Status *status)
	Make type native-endian. More...
static hid_t	get_tag (mhdf_FileHandle file_handle, const char *tag_name, hid_t *id_type, mhdf_Status *status)
static hid_t	get_tag_type (FileHandle *file_ptr, const char *tag_path, mhdf_Status *status)
static int	store_tag_val_in_attrib (hid_t tag_id, const char *attrib_name, hid_t type_id, const void *value, hsize_t value_size, mhdf_Status *status)
static hid_t	create_tag_common (mhdf_FileHandle file_handle, const char *tag_name, enum mhdf_TagDataType tag_type, int size, int storage, const void *default_value, int default_value_size_in, const void *global_value, int global_value_size_in, hid_t hdf_type, hid_t hdf_base_type, mhdf_Status *status)
hid_t	mhdf_getTagDataType (mhdf_FileHandle file_handle, const char *tag_name, mhdf_Status *status)
	Get handle to HDF5 type object for tag data. More...
void	mhdf_createTag (mhdf_FileHandle file_handle, const char *tag_name, enum mhdf_TagDataType tag_type, int size, int storage, const void *default_value, const void *global_value, hid_t hdf_type, hid_t hdf_base_type, mhdf_Status *status)
	Add a tag to the file. More...
void	mhdf_createVarLenTag (mhdf_FileHandle file_handle, const char *tag_name, enum mhdf_TagDataType tag_type, int storage, const void *default_value, int default_value_length, const void *global_value, int global_value_length, hid_t hdf_type, hid_t hdf_base_type, mhdf_Status *status)
	Add variable-length tag to file. More...
int	mhdf_getNumberTags (mhdf_FileHandle file_handle, mhdf_Status *status)
	Get the number of tags in the file. More...
char **	mhdf_getTagNames (mhdf_FileHandle file_handle, int *num_names_out, mhdf_Status *status)
	Get the name for each tag defined in the file. More...
static int	get_attrib_array_length_handle (hid_t attrib_id)
static int	get_attrib_array_length_name (hid_t file, const char *path)
void	mhdf_getTagInfo (mhdf_FileHandle file_handle, const char *tag_name, enum mhdf_TagDataType *class_out, int *size_out, int *tstt_storage_out, int *have_default_out, int *have_global_out, int *have_sparse_out, mhdf_Status *status)
	Get the description of a specified tag. More...
static int	read_tag_attrib_data (hid_t tag_id, const char *attrib_name, hid_t type_id, void *data, int is_var_len, mhdf_Status *status)
void	mhdf_getTagValues (mhdf_FileHandle file_handle, const char *tag_name, hid_t output_data_type, void *default_value, void *global_value, mhdf_Status *status)
	Get the default and global values of the tag. More...
int	mhdf_haveDenseTag (mhdf_FileHandle file_handle, const char *tag_name, const char *type_handle, mhdf_Status *status)
	Check if the file contains dense tag data for the specified tag and element group. More...
hid_t	mhdf_createDenseTagData (mhdf_FileHandle file_handle, const char *tag_name, const char *type_handle, long num_values, mhdf_Status *status)
	Create an object to hold dense tag values for a given element group. More...
hid_t	mhdf_openDenseTagData (mhdf_FileHandle file_handle, const char *tag_name, const char *type_handle, long *num_values_out, mhdf_Status *status)
	Open the object containing dense tag values for a given element group. More...
void	mhdf_createSparseTagData (mhdf_FileHandle file_handle, const char *tag_name, long num_values, hid_t handles_out[2], mhdf_Status *status)
	Create file objects to store sparse tag data. More...
void	mhdf_createVarLenTagData (mhdf_FileHandle file_handle, const char *tag_name, long num_entities, long num_values, hid_t handles_out[3], mhdf_Status *status)
	Create file objects to store (sparse) variable-length tag data. More...
void	mhdf_openSparseTagData (mhdf_FileHandle file_handle, const char *tag_name, long *num_entity_out, long *num_values_out, hid_t handles_out[3], mhdf_Status *status)
	Create file objects to read sparse tag data. More...
void	mhdf_writeSparseTagEntities (hid_t table_id, long offset, long count, hid_t int_type, const void *id_list, mhdf_Status *status)
	Write Global ID list for sparse tag data. More...
void	mhdf_writeSparseTagEntitiesWithOpt (hid_t table_id, long offset, long count, hid_t int_type, const void *id_list, hid_t io_prop, mhdf_Status *status)
void	mhdf_writeTagValues (hid_t table_id, long offset, long count, hid_t tag_type, const void *tag_data, mhdf_Status *status)
	Write tag values. More...
void	mhdf_writeTagValuesWithOpt (hid_t table_id, long offset, long count, hid_t tag_type, const void *tag_data, hid_t io_prop, mhdf_Status *status)
void	mhdf_writeSparseTagIndices (hid_t table_id, long offset, long count, hid_t int_type, const void *indices, mhdf_Status *status)
	Write sparse tag end indices for variable-length tag data. More...
void	mhdf_writeSparseTagIndicesWithOpt (hid_t table_id, long offset, long count, hid_t int_type, const void *indices, hid_t io_prop, mhdf_Status *status)
void	mhdf_readSparseTagEntities (hid_t table_id, long offset, long count, hid_t int_type, void *id_list, mhdf_Status *status)
	Read Global ID list for sparse tag data. More...
void	mhdf_readSparseTagEntitiesWithOpt (hid_t table_id, long offset, long count, hid_t int_type, void *id_list, hid_t io_prop, mhdf_Status *status)
void	mhdf_readTagValues (hid_t table_id, long offset, long count, hid_t tag_type, void *tag_data, mhdf_Status *status)
	Read tag values. More...
void	mhdf_readTagValuesWithOpt (hid_t table_id, long offset, long count, hid_t tag_type, void *tag_data, hid_t io_prop, mhdf_Status *status)
void	mhdf_readSparseTagIndices (hid_t table_id, long offset, long count, hid_t int_type, void *indices, mhdf_Status *status)
	Read sparse tag end indices for variable-length tag data. More...
void	mhdf_readSparseTagIndicesWithOpt (hid_t table_id, long offset, long count, hid_t int_type, void *indices, hid_t io_prop, mhdf_Status *status)

Function Documentation

create_tag_common()

static hid_t create_tag_common ( mhdf_FileHandle  file_handle, const char *  tag_name, enum mhdf_TagDataType  tag_type, int  size, int  storage, const void *  default_value, int  default_value_size_in, const void *  global_value, int  global_value_size_in, hid_t  hdf_type, hid_t  hdf_base_type, mhdf_Status *  status  )

static

Definition at line 235 of file tags.c.

{
    hid_t temp_id, group_id, tag_id;
    char* path;
    FileHandle* file_ptr;
    herr_t rval;
    hsize_t arr_len;
    int one = 1, var_len = 0;
    hsize_t default_value_size = default_value_size_in;
    hsize_t global_value_size  = global_value_size_in;
    int close_base_type        = 0;
 
    /* Force standard data types over user-specified types */
 
    if( tag_type != mhdf_OPAQUE ) hdf_type = 0;
    if( tag_type != mhdf_ENTITY_ID ) hdf_base_type = 0;
 
    /* Validate input */
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
    if( !tag_name || !*tag_name )
    {
        mhdf_setFail( status, "Invalid tag name" );
        return -1;
    }
 
    /* Open the tag group */
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
#else
    group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
#endif
    if( group_id < 0 )
    {
        mhdf_setFail( status, "H5Gopen(\"%s\") failed.", TAG_GROUP );
        return -1;
    }
 
    /* Create path string for tag object */
 
    path = mhdf_name_to_path_copy( tag_name, status );
    if( !path )
    {
        H5Gclose( group_id );
        return -1;
    }
 
    /* Create group for this tag */
 
#if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
    tag_id = H5Gcreate2( group_id, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
#else
    tag_id   = H5Gcreate( group_id, path, 3 );
#endif
    if( tag_id < 0 )
    {
        mhdf_setFail( status, "H5Gcreate( \"%s\" ) failed.", path );
        free( path );
        H5Gclose( group_id );
        return -1;
    }
 
    /* Store the tag name as the comment on the group entry */
 
    rval = H5Gset_comment( group_id, path, tag_name );
    H5Gclose( group_id );
    free( path );
    if( rval < 0 )
    {
        mhdf_setFail( status, "H5Gset_comment failed for tag \"%s\"", tag_name );
        H5Gclose( tag_id );
        return -1;
    }
 
    /* Store TSTT tag type as attribute */
 
    rval = mhdf_create_scalar_attrib( tag_id, TAG_TYPE_ATTRIB, H5T_NATIVE_INT, &storage, status );
    if( !rval )
    {
        H5Gclose( tag_id );
        return -1;
    }
 
    if( hdf_type )
    {
        hdf_type = H5Tcopy( hdf_type );
        arr_len  = 1;
    }
    else
    {
        switch( tag_type )
        {
            default:
            case mhdf_OPAQUE:
                arr_len  = 1;
                hdf_type = H5Tcreate( H5T_OPAQUE, abs( size ) );
                H5Tset_tag( hdf_type, "tag_data" );
                break;
 
            case mhdf_BITFIELD:
                arr_len = 1;
                if( size <= 0 )
                {
                    mhdf_setFail( status, "Invalid size (%d) for bit tag.", (int)size );
                    return -1;
                }
                else if( size <= 8 )
                    hdf_type = H5Tcopy( H5T_NATIVE_B8 );
                else if( size <= 16 )
                    hdf_type = H5Tcopy( H5T_NATIVE_B16 );
                else if( size <= 32 )
                    hdf_type = H5Tcopy( H5T_NATIVE_B32 );
                else if( size <= 64 )
                    hdf_type = H5Tcopy( H5T_NATIVE_B64 );
                else
                {
                    mhdf_setFail( status, "Cannot create a bit tag larger than 64-bits.  %d bits requested.\n",
                                  (int)size );
                    return -1;
                }
 
                if( 0 > H5Tset_precision( hdf_type, size ) )
                {
                    mhdf_setFail( status, "H5Tset_precision failed." );
                    return -1;
                }
                break;
 
            case mhdf_ENTITY_ID:
                arr_len  = abs( size );
                hdf_type = H5Tcopy( H5T_NATIVE_ULONG );
                break;
 
            case mhdf_BOOLEAN:
                arr_len  = abs( size );
                hdf_type = H5Tcopy( H5T_NATIVE_UCHAR );
                break;
 
            case mhdf_INTEGER:
                arr_len  = abs( size );
                hdf_type = H5Tcopy( H5T_NATIVE_INT );
                break;
 
            case mhdf_FLOAT:
                arr_len  = abs( size );
                hdf_type = H5Tcopy( H5T_NATIVE_DOUBLE );
                break;
        }
    }
 
    if( hdf_type <= 0 )
    {
        mhdf_setFail( status, "Failed to create tag type object." );
        H5Gclose( tag_id );
        return -1;
    }
 
    if( hdf_base_type && H5Tget_class( hdf_type ) != H5Tget_class( hdf_base_type ) )
    {
        mhdf_setFail( status, "Invalid base type for tag default/global data" );
        H5Gclose( tag_id );
        return -1;
    }
 
    if( size < -1 || !arr_len )
    {
        mhdf_setFail( status, "Invalid 'size' parameter passed to mhdf_createTag (%d)", (int)size );
        H5Gclose( tag_id );
        return -1;
    }
    else if( size == -1 )
    {
        /* Note: we don't do anything with this here.  We rely on
         *       the app to ask us to create the index table later.
         */
        arr_len = 1;
        /* need to know this later, when storing default/global values */
        var_len = 1;
    }
    else if( arr_len > 1 )
    {
#if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
        temp_id = H5Tarray_create2( hdf_type, 1, &arr_len );
#else
        temp_id = H5Tarray_create( hdf_type, 1, &arr_len, NULL );
#endif
        H5Tclose( hdf_type );
        if( temp_id < 0 )
        {
            mhdf_setFail( status, "Failed to create tag type object." );
            H5Gclose( tag_id );
            return -1;
        }
        hdf_type = temp_id;
 
        if( hdf_base_type )
        {
            if( H5Tequal( hdf_base_type, hdf_type ) > 0 )
            {
                hdf_base_type = hdf_type;
            }
            else
            {
#if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
                temp_id = H5Tarray_create2( hdf_base_type, 1, &arr_len );
#else
                temp_id = H5Tarray_create( hdf_base_type, 1, &arr_len, NULL );
#endif
                if( temp_id < 0 )
                {
                    mhdf_setFail( status, "Failed to create tag type object." );
                    H5Gclose( tag_id );
                    H5Tclose( hdf_type );
                    return -1;
                }
                hdf_base_type   = temp_id;
                close_base_type = 1;
            }
        }
    }
 
    if( !hdf_base_type ) hdf_base_type = hdf_type;
 
        /* Create tag type object, or write attribute if opaque */
 
#if defined( H5Tcommit_vers ) && H5Tcommit_vers > 1
    rval = H5Tcommit2( tag_id, TAG_TYPE_NAME, hdf_type, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
#else
    rval     = H5Tcommit( tag_id, TAG_TYPE_NAME, hdf_type );
#endif
    if( rval < 0 )
    {
        mhdf_setFail( status, "H5Tcommit failed for tag \"%s\"", tag_name );
        if( close_base_type ) H5Tclose( hdf_base_type );
        H5Tclose( hdf_type );
        H5Gclose( tag_id );
        return -1;
    }
 
    /* If tag is entity handle, make note of it */
    if( tag_type == mhdf_ENTITY_ID )
    {
        rval = mhdf_create_scalar_attrib( tag_id, TAG_HANDLE_TYPE_ATTRIB, H5T_NATIVE_INT, &one, status );
        if( !rval )
        {
            if( close_base_type ) H5Tclose( hdf_base_type );
            H5Gclose( tag_id );
            H5Tclose( hdf_type );
            return -1;
        }
    }
 
    /* Store the default value as a attribute of the tag group */
 
    if( default_value )
    {
        rval = store_tag_val_in_attrib( tag_id, TAG_DEFAULT_ATTRIB, hdf_base_type, default_value,
                                        var_len ? default_value_size : 1, status );
        if( !rval )
        {
            if( close_base_type ) H5Tclose( hdf_base_type );
            H5Gclose( tag_id );
            H5Tclose( hdf_type );
            return -1;
        }
    }
 
    /* Store global tag value as attribute */
 
    if( global_value )
    {
        rval = store_tag_val_in_attrib( tag_id, TAG_GLOBAL_ATTRIB, hdf_base_type, global_value,
                                        var_len ? global_value_size : 1, status );
        if( !rval )
        {
            if( close_base_type ) H5Tclose( hdf_base_type );
            H5Gclose( tag_id );
            H5Tclose( hdf_type );
            return -1;
        }
    }
 
    if( close_base_type ) H5Tclose( hdf_base_type );
    H5Tclose( hdf_type );
    mhdf_setOkay( status );
    return tag_id;
}

References struct_FileHandle::hdf_handle, mhdf_BITFIELD, mhdf_BOOLEAN, mhdf_check_valid_file(), mhdf_create_scalar_attrib(), mhdf_ENTITY_ID, mhdf_FLOAT, mhdf_INTEGER, mhdf_name_to_path_copy(), mhdf_OPAQUE, mhdf_setFail(), mhdf_setOkay(), size, store_tag_val_in_attrib(), TAG_DEFAULT_ATTRIB, TAG_GLOBAL_ATTRIB, TAG_GROUP, TAG_HANDLE_TYPE_ATTRIB, TAG_TYPE_ATTRIB, and TAG_TYPE_NAME.

Referenced by mhdf_createTag(), and mhdf_createVarLenTag().

get_attrib_array_length_handle()

static int get_attrib_array_length_handle ( hid_t  attrib_id )

static

Definition at line 741 of file tags.c.

{
    hid_t type_id;
    int rank;
    hsize_t dims[H5S_MAX_RANK];
    int perm[H5S_MAX_RANK];
 
    type_id = H5Aget_type( attrib_id );
    switch( H5Tget_class( type_id ) )
    {
        case H5T_NO_CLASS:
            dims[0] = -1;
            break;
        case H5T_OPAQUE:
            dims[0] = H5Tget_size( type_id );
            break;
        case H5T_ARRAY:
#if defined( H5Tget_array_dims_vers ) && H5Tget_array_dims_vers > 1
            (void)perm; /* suppress warning */
            rank = H5Tget_array_dims2( type_id, dims );
#else
            rank = H5Tget_array_dims( type_id, dims, perm );
#endif
            if( rank == 1 )
                break;
            else
                return -1;
        default:
            dims[0] = 1;
            break;
    }
 
    H5Tclose( type_id );
    return dims[0];
}

Referenced by get_attrib_array_length_name().

get_attrib_array_length_name()

static int get_attrib_array_length_name ( hid_t  file, const char *  path  )

static

Definition at line 793 of file tags.c.

{
    hid_t attrib_id;
    int result;
 
    attrib_id = H5Aopen_name( file, path );
    if( attrib_id < 0 ) return -1;
 
    result = get_attrib_array_length_handle( attrib_id );
    H5Aclose( attrib_id );
    return result;
}

References get_attrib_array_length_handle().

Referenced by mhdf_getTagInfo(), and read_tag_attrib_data().

get_tag()

static hid_t get_tag ( mhdf_FileHandle  file_handle, const char *  tag_name, hid_t *  id_type, mhdf_Status *  status  )

static

Definition at line 106 of file tags.c.

{
    hid_t group_id, tag_id;
    char* path;
    FileHandle* file_ptr;
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
    if( NULL != id_type ) *id_type = file_ptr->id_type;
 
    path = mhdf_name_to_path_copy( tag_name, status );
    if( NULL == path ) return -1;
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
#else
    group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
#endif
    if( group_id < 0 )
    {
        mhdf_setFail( status, "Failed to open tag group." );
        free( path );
        return -1;
    }
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    tag_id = H5Gopen2( group_id, path, H5P_DEFAULT );
#else
    tag_id   = H5Gopen( group_id, path );
#endif
    H5Gclose( group_id );
    free( path );
    if( tag_id < 0 )
    {
        mhdf_setFail( status, "Failed to open tag data for tag \"%s\".", tag_name );
        return -1;
    }
 
    mhdf_setOkay( status );
    return tag_id;
}

References struct_FileHandle::hdf_handle, struct_FileHandle::id_type, mhdf_check_valid_file(), mhdf_name_to_path_copy(), mhdf_setFail(), mhdf_setOkay(), and TAG_GROUP.

Referenced by mhdf_createSparseTagData(), mhdf_createVarLenTagData(), mhdf_getTagInfo(), mhdf_getTagValues(), and mhdf_openSparseTagData().

get_tag_type()

static hid_t get_tag_type ( FileHandle *  file_ptr, const char *  tag_path, mhdf_Status *  status  )

static

Definition at line 149 of file tags.c.

{
    hid_t group_id, tag_id, type_id;
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
#else
    group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
#endif
    if( group_id < 0 )
    {
        mhdf_setFail( status, "Failed to open tag group." );
        return -1;
    }
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    tag_id = H5Gopen2( group_id, tag_path, H5P_DEFAULT );
#else
    tag_id   = H5Gopen( group_id, tag_path );
#endif
    H5Gclose( group_id );
    if( tag_id < 0 )
    {
        mhdf_setFail( status, "Failed to open group for tag \"%s\".", tag_path );
        return -1;
    }
 
#if defined( H5Topen_vers ) && H5Topen_vers > 1
    type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
#else
    type_id  = H5Topen( tag_id, TAG_TYPE_NAME );
#endif
    H5Gclose( tag_id );
    if( type_id < 0 )
    {
        mhdf_setFail( status, "Failed to open type data for tag \"%s\".", tag_path );
        return -1;
    }
 
    return type_id;
}

References struct_FileHandle::hdf_handle, mhdf_setFail(), TAG_GROUP, and TAG_TYPE_NAME.

Referenced by mhdf_createDenseTagData(), and mhdf_getTagDataType().

mhdf_createDenseTagData()

hid_t mhdf_createDenseTagData	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		const char *	elem_group,
		long	num_values,
		mhdf_Status *	status
	)

Create an object to hold dense tag values for a given element group.

Parameters

file_handle	The file.
tag_name	The tag.
elem_group	The element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
num_values	The number of tag values to be written. Must be The same as the number of elements in the group. Specified here to allow tag values to be written before node coordinates, element connectivity or meshsets.
status	Passed back status of API call.

Returns

Handle to data object in file.

Definition at line 1268 of file tags.c.

{
    char* path;
    hid_t elem_id, data_id, type_id;
    FileHandle* file_ptr;
    size_t name_len, path_len, dir_len;
    hsize_t size;
    API_BEGIN;
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
    if( type_handle == mhdf_node_type_handle() )
    {
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
        elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
#else
        elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
#endif
        if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
    }
    else if( type_handle == mhdf_set_type_handle() )
    {
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
        elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
#else
        elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
#endif
        if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
    }
    else
    {
        elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
    }
    if( elem_id < 0 ) return -1;
 
    dir_len  = strlen( DENSE_TAG_SUBGROUP );
    name_len = mhdf_name_to_path( tag_name, NULL, 0 );
    path_len = dir_len + name_len + 1;
    path     = (char*)mhdf_malloc( path_len, status );
    if( NULL == path )
    {
        H5Gclose( elem_id );
        return -1;
    }
    strcpy( path, DENSE_TAG_SUBGROUP );
    mhdf_name_to_path( tag_name, path + dir_len, name_len + 1 );
 
    type_id = get_tag_type( file_ptr, path + dir_len, status );
    if( type_id < 0 )
    {
        H5Gclose( elem_id );
        return -1;
    }
 
    size    = (hsize_t)num_values;
    data_id = mhdf_create_table( elem_id, path, type_id, 1, &size, status );
    free( path );
    H5Gclose( elem_id );
    H5Tclose( type_id );
 
    if( data_id > 0 ) mhdf_setOkay( status );
 
    API_END_H( 1 );
    return data_id;
}

References API_BEGIN, API_END_H, DENSE_TAG_SUBGROUP, get_tag_type(), struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_create_table(), mhdf_elem_group_from_handle(), mhdf_malloc(), mhdf_name_to_path(), mhdf_node_type_handle(), mhdf_set_type_handle(), mhdf_setFail(), mhdf_setOkay(), NODE_GROUP, SET_GROUP, and size.

Referenced by moab::WriteHDF5::create_tag().

mhdf_createSparseTagData()

void mhdf_createSparseTagData	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		long	num_values,
		hid_t	entities_and_values_out[2],
		mhdf_Status *	status
	)

Create file objects to store sparse tag data.

Create the file objects to store all sparse data for a given tag in. The sparse data is stored in a pair of objects. The first is a vector of global IDs. The second is a vector of tag values for each entity specified in the list of global IDs.

Parameters

file_handle	The file.
tag_name	The tag.
num_values	The number of tag values to be written.
entities_and_values_out	The handles to the file objects. The first is the vector of global IDs. The second is the list of corresponding tag values.
status	Passed back status of API call.

Definition at line 1402 of file tags.c.

{
    hid_t tag_id, index_id, data_id, type_id, id_type;
    hsize_t count = (hsize_t)num_values;
    API_BEGIN;
 
    tag_id = get_tag( file_handle, tag_name, &id_type, status );
    if( tag_id < 0 ) return;
 
#if defined( H5Topen_vers ) && H5Topen_vers > 1
    type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
#else
    type_id = H5Topen( tag_id, TAG_TYPE_NAME );
#endif
    if( type_id < 0 )
    {
        H5Gclose( tag_id );
        mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
        return;
    }
 
    index_id = mhdf_create_table( tag_id, SPARSE_ENTITY_NAME, id_type, 1, &count, status );
    if( index_id < 0 )
    {
        H5Gclose( tag_id );
        H5Tclose( type_id );
        return;
    }
 
    data_id = mhdf_create_table( tag_id, SPARSE_VALUES_NAME, type_id, 1, &count, status );
    H5Tclose( type_id );
    H5Gclose( tag_id );
    if( data_id < 0 )
    {
        H5Dclose( index_id );
        return;
    }
 
    handles_out[0] = index_id;
    handles_out[1] = data_id;
    mhdf_setOkay( status );
    API_END_H( 2 );
}

References API_BEGIN, API_END_H, get_tag(), mhdf_create_table(), mhdf_setFail(), mhdf_setOkay(), SPARSE_ENTITY_NAME, SPARSE_VALUES_NAME, and TAG_TYPE_NAME.

Referenced by moab::WriteHDF5::create_tag().

mhdf_createTag()

void mhdf_createTag	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		enum mhdf_TagDataType	tag_type,
		int	size,
		int	storage,
		const void *	default_value,
		const void *	global_value,
		hid_t	hdf_type,
		hid_t	mhdf_base_type,
		mhdf_Status *	status
	)

Add a tag to the file.

Add a new tag to the file. This function must be called to define the tag characteristics before values for the tag can be written.

Parameters

file_handle	The file
tag_name	The tag name
tag_type	The tag type.
size	If tag_type == mhdf_BITFIELD, the number of bits. If tag_type == mhdf_OPAQUE, the size of the opaque type in bytes. Otherwise the length of the array of tag_type entities associated with each mesh entity, or 1 for a scalar value.
storage	MOAB storage type (dense, sparse, etc.)
default_value	Default value for tag, or NULL if none.
global_value	Global value for tag, or NULL if none.
hdf_type	If non-zero, assumed to be a user-specified type for opaque data. Ignored if tag_type is not mhdf_OPAQUE.
hdf_base_type	Ignored if hdf_type is non-zero. If hdf_type is zero and this type is non-zero, it is used either as the type or as the base type for an array type for default_value and global_value, respectively. Typically used to specify the input data type for mhdf_ENTITY_ID tags.

Definition at line 570 of file tags.c.

{
    hid_t tag_id;
    API_BEGIN;
    tag_id = create_tag_common( file_handle, tag_name, tag_type, size, storage, default_value, 1, global_value, 1,
                                hdf_type, hdf_base_type, status );
    if( tag_id >= 0 ) H5Gclose( tag_id );
    API_END;
}

References API_BEGIN, API_END, create_tag_common(), and size.

Referenced by moab::WriteHDF5::create_tag().

mhdf_createVarLenTag()

void mhdf_createVarLenTag	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		enum mhdf_TagDataType	tag_type,
		int	storage,
		const void *	default_value,
		int	default_value_length,
		const void *	global_value,
		int	global_value_length,
		hid_t	hdf_type,
		hid_t	hdf_base_type,
		mhdf_Status *	status
	)

Add variable-length tag to file.

Add a new tag to the file. This function must be called to define the tag characteristics before values for the tag can be written. Use this function if the tag values are not fixed-length.

Parameters

file_handle	The file
tag_name	The tag name
tag_type	The tag type.
storage	MOAB storage type (dense, sparse, etc.)
default_value	Default value for tag, or NULL if none.
default_value_length	Length of default value.
global_value	Global value for tag, or NULL if none.
global_value_length	Length of global value.
hdf_type	If non-zero, assumed to be a user-specified type for opaque data. Ignored if tag_type is not mhdf_OPAQUE.
hdf_base_type	Ignored if hdf_type is non-zero. If hdf_type is zero and this type is non-zero, it is used either as the type or as the base type for an array type for default_value and global_value, respectively. Typically used to specify the input data type for mhdf_ENTITY_ID tags.

Definition at line 589 of file tags.c.

{
    hid_t tag_id;
    int one = 1;
 
    API_BEGIN;
    tag_id = create_tag_common( file_handle, tag_name, tag_type, -1, storage, default_value, default_value_length,
                                global_value, global_value_length, hdf_type, hdf_base_type, status );
    if( tag_id >= 0 )
    {
        mhdf_create_scalar_attrib( tag_id, TAG_VARLEN_ATTRIB, H5T_NATIVE_INT, &one, status );
        H5Gclose( tag_id );
    }
    API_END;
}

References API_BEGIN, API_END, create_tag_common(), mhdf_create_scalar_attrib(), and TAG_VARLEN_ATTRIB.

Referenced by moab::WriteHDF5::create_tag().

mhdf_createVarLenTagData()

void mhdf_createVarLenTagData	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		long	num_entities,
		long	num_values,
		hid_t	entities_and_values_out[3],
		mhdf_Status *	status
	)

Create file objects to store (sparse) variable-length tag data.

Create the file objects to store all sparse data for a given tag in. The sparse data is stored in a pair of objects. The first is a vector of global IDs. The second is a vector of tag values for each entity specified in the list of global IDs.

Parameters

file_handle	The file.
tag_name	The tag.
num_entities	The number of entities for which tag values are to be stored
num_values	The total number of scalar values to be written (the total number of bytes of data for all tags for opaque data.)
entities_and_values_out	The handles to the file objects. The first is the vector of global IDs. The second is the list of corresponding tag values. The third is the handle to the index table.
status	Passed back status of API call.

Definition at line 1450 of file tags.c.

{
    hid_t tag_id, index_id, data_id, type_id, offset_id, id_type;
    hsize_t count = (hsize_t)num_entities;
    API_BEGIN;
 
    tag_id = get_tag( file_handle, tag_name, &id_type, status );
    if( tag_id < 0 ) return;
 
#if defined( H5Topen_vers ) && H5Topen_vers > 1
    type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
#else
    type_id = H5Topen( tag_id, TAG_TYPE_NAME );
#endif
    if( type_id < 0 )
    {
        H5Gclose( tag_id );
        mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
        return;
    }
 
    index_id = mhdf_create_table( tag_id, SPARSE_ENTITY_NAME, id_type, 1, &count, status );
    if( index_id < 0 )
    {
        H5Gclose( tag_id );
        H5Tclose( type_id );
        return;
    }
 
    offset_id = mhdf_create_table( tag_id, TAG_VAR_INDICES, MHDF_INDEX_TYPE, 1, &count, status );
    if( index_id < 0 )
    {
        H5Dclose( offset_id );
        H5Gclose( tag_id );
        H5Tclose( type_id );
        return;
    }
 
    count   = (hsize_t)num_values;
    data_id = mhdf_create_table( tag_id, SPARSE_VALUES_NAME, type_id, 1, &count, status );
    H5Tclose( type_id );
    H5Gclose( tag_id );
    if( data_id < 0 )
    {
        H5Dclose( offset_id );
        H5Dclose( index_id );
        return;
    }
 
    handles_out[0] = index_id;
    handles_out[1] = data_id;
    handles_out[2] = offset_id;
    mhdf_setOkay( status );
    API_END_H( 3 );
}

References API_BEGIN, API_END_H, get_tag(), mhdf_create_table(), MHDF_INDEX_TYPE, mhdf_setFail(), mhdf_setOkay(), SPARSE_ENTITY_NAME, SPARSE_VALUES_NAME, TAG_TYPE_NAME, and TAG_VAR_INDICES.

Referenced by moab::WriteHDF5::create_tag().

mhdf_getNativeType()

hid_t mhdf_getNativeType	(	hid_t	input_type,
		int	size,
		mhdf_Status *	status
	)

Make type native-endian.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Definition at line 30 of file tags.c.

{
    H5T_sign_t sgn;
    H5T_class_t cls;
    hid_t tmp_id, type_id;
 
    mhdf_setOkay( status );
 
    cls = H5Tget_class( input_type );
    switch( cls )
    {
        case H5T_FLOAT:
            switch( size )
            {
                case 4:
                    return H5T_NATIVE_FLOAT;
                case 8:
                    return H5T_NATIVE_DOUBLE;
                case 16:
                    return H5T_NATIVE_LDOUBLE;
                default:
                    mhdf_setFail( status, "Invalid size for floating point type: %d", size );
                    return -1;
            }
 
        case H5T_INTEGER:
            sgn = H5Tget_sign( input_type );
            if( H5T_SGN_ERROR == sgn )
            {
                mhdf_setFail( status, "Internall errror calling H5Tget_sign." );
                return -1;
            }
            if( sizeof( char ) == size )
                return sgn == H5T_SGN_NONE ? H5T_NATIVE_UCHAR : H5T_NATIVE_SCHAR;
            else if( sizeof( short ) == size )
                return sgn == H5T_SGN_NONE ? H5T_NATIVE_USHORT : H5T_NATIVE_SHORT;
            else if( sizeof( int ) == size )
                return sgn == H5T_SGN_NONE ? H5T_NATIVE_UINT : H5T_NATIVE_INT;
            else if( sizeof( long ) == size )
                return sgn == H5T_SGN_NONE ? H5T_NATIVE_ULONG : H5T_NATIVE_LONG;
            else if( (int)H5Tget_size( H5T_NATIVE_LLONG ) == size )
                return sgn == H5T_SGN_NONE ? H5T_NATIVE_ULLONG : H5T_NATIVE_LLONG;
 
            mhdf_setFail( status, "Invalid size for integer type: %d", size );
            return -1;
 
        case H5T_ENUM:
            tmp_id = H5Tget_super( input_type );
            if( tmp_id < 0 )
            {
                mhdf_setFail( status, "Internal error calling H5Tget_super." );
                return -1;
            }
            type_id = mhdf_getNativeType( tmp_id, size, status );
            H5Tclose( tmp_id );
            return type_id;
 
        case H5T_TIME:
        case H5T_OPAQUE:
        case H5T_REFERENCE:
            mhdf_setFail( status, "Unsupported type class." );
            return -1;
 
        case H5T_COMPOUND:
        case H5T_VLEN:
        case H5T_ARRAY:
        case H5T_STRING:
            mhdf_setFail( status, "Only atomic types are supported." );
            return -1;
 
        default:
            mhdf_setFail( status, "Internal error calling H5Tget_class.  Bad handle?" );
            return -1;
    }
}

References mhdf_getNativeType(), mhdf_setFail(), mhdf_setOkay(), and size.

Referenced by mhdf_getNativeType().

mhdf_getNumberTags()

int mhdf_getNumberTags	(	mhdf_FileHandle	file_handle,
		mhdf_Status *	status
	)

Get the number of tags in the file.

Parameters

file_handle	The file.
status	Passed back status of API call.

Returns

The number of tags.

Definition at line 615 of file tags.c.

{
    hid_t group_id;
    hsize_t result;
    FileHandle* file_ptr;
    API_BEGIN;
 
    /* Validate input */
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
        /* Open the tags group */
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
#else
    group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
#endif
    if( group_id < 0 )
    {
        mhdf_setFail( status, "H5Gopen(\"%s\") failed", TAG_GROUP );
        return -1;
    }
 
    /* Get number of objects in tags group */
 
    if( H5Gget_num_objs( group_id, &result ) < 0 )
    {
        mhdf_setFail( status, "Internal failure calling H5Gget_num_objs." );
        H5Gclose( group_id );
        return -1;
    }
 
    H5Gclose( group_id );
    mhdf_setOkay( status );
    API_END;
    return (int)result;
}

References API_BEGIN, API_END, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_setFail(), mhdf_setOkay(), and TAG_GROUP.

mhdf_getTagDataType()

hid_t mhdf_getTagDataType	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		mhdf_Status *	status
	)

Get handle to HDF5 type object for tag data.

Definition at line 537 of file tags.c.

{
    FileHandle* file_ptr;
    hid_t result;
    char* path;
    API_BEGIN;
 
    /* Validate input */
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
    if( !tag_name || !*tag_name )
    {
        mhdf_setFail( status, "Invalid tag name" );
        return -1;
    }
 
    /* Create path string for tag object */
 
    path = mhdf_name_to_path_copy( tag_name, status );
    if( !path )
    {
        return -1;
    }
 
    result = get_tag_type( file_ptr, path, status );
 
    free( path );
    API_END;
    return result;
}

References API_BEGIN, API_END, get_tag_type(), mhdf_check_valid_file(), mhdf_name_to_path_copy(), and mhdf_setFail().

mhdf_getTagInfo()

void mhdf_getTagInfo	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		enum mhdf_TagDataType *	class_out,
		int *	size_out,
		int *	tstt_storage_out,
		int *	have_default_out,
		int *	have_global_out,
		int *	have_sparse_out,
		mhdf_Status *	status
	)

Get the description of a specified tag.

Get everything about a tag except the actual values.

Parameters

file_handle	The file.
tag_name	The name of the tag to retrieve the data for.
class_out	The TSTT class of the tag data.
size_out	Depends on value of class_out: mhdf_OPAQUE - size of opaque data in bytes mhdf_BITFIELD - number of bits if data is fixed-length array, length of array if data is single value, 1 if data is a variable-length array, -1
tstt_storage_out	The value of the TSTT enum for storage (dense, sparse, etc.)
have_default_out	Non-zero if file contains a default value for the tag. Length of default value if variable-lenth tag.
have_global_out	Non-zero if the file contains a global/mesh value for the tag.
have_sparse_out	Non-zero if the file contains a sparse data table for this tag.

Definition at line 806 of file tags.c.

{
    hid_t tag_id, type_id, super_id;
    int i, rval, is_handle;
    hsize_t size, sup_size;
    unsigned int idx;
    int rank, var_data;
    hsize_t dims[H5S_MAX_RANK];
    int perm[H5S_MAX_RANK];
    H5T_class_t class_tmp;
 
    API_BEGIN;
 
    /* Validate input */
    if( NULL == tag_name || NULL == class_out || NULL == size_out || NULL == tstt_storage_out ||
        NULL == have_default_out || NULL == have_global_out || NULL == have_sparse_out )
    {
        mhdf_setFail( status, "Invalid input." );
        return;
    }
 
    /* Get group for tag */
    tag_id = get_tag( file_handle, tag_name, NULL, status );
    if( tag_id < 0 ) return;
 
    /* Check for sparse data */
    rval = mhdf_is_in_group( tag_id, SPARSE_ENTITY_NAME, status );
    if( rval < 0 )
    {
        H5Gclose( tag_id );
        return;
    }
    *have_sparse_out = rval ? 1 : 0;
 
    /* Check for variable-length tag data */
    rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
    if( rval < 0 )
    {
        H5Gclose( tag_id );
        return;
    }
    var_data = rval ? 1 : 0;
 
    /* Check if have default value for tag */
    rval = mhdf_find_attribute( tag_id, TAG_DEFAULT_ATTRIB, &idx, status );
    if( rval < 0 )
    {
        H5Gclose( tag_id );
        return;
    }
    if( !rval )
        *have_default_out = 0;
    else if( !var_data )
        *have_default_out = 1;
    else
    {
        /* *have_default_out = get_attrib_array_length_index( tag_id, index ); */
        *have_default_out = get_attrib_array_length_name( tag_id, TAG_DEFAULT_ATTRIB );
        if( *have_default_out < 0 )
        {
            mhdf_setFail( status, "Error checking length of default value for tag: %s\n", tag_name );
            H5Gclose( tag_id );
            return;
        }
    }
 
    /* Check if have global value for tag */
    rval = mhdf_find_attribute( tag_id, TAG_GLOBAL_ATTRIB, &idx, status );
    if( rval < 0 )
    {
        H5Gclose( tag_id );
        return;
    }
    if( !rval )
        *have_global_out = 0;
    else if( !var_data )
        *have_global_out = 1;
    else
    {
        /* *have_global_out = get_attrib_array_length_index( tag_id, index ); */
        *have_global_out = get_attrib_array_length_name( tag_id, TAG_GLOBAL_ATTRIB );
        if( *have_global_out < 0 )
        {
            mhdf_setFail( status, "Error checking length of global value for tag: %s\n", tag_name );
            H5Gclose( tag_id );
            return;
        }
    }
 
    /* Get TSTT tag class */
    rval = mhdf_read_scalar_attrib( tag_id, TAG_TYPE_ATTRIB, H5T_NATIVE_INT, tstt_storage_out, status );
    if( rval < 1 )
    {
        H5Gclose( tag_id );
        return;
    }
 
    /* Check if tag is storing entity handles */
    rval = mhdf_find_attribute( tag_id, TAG_HANDLE_TYPE_ATTRIB, &idx, status );
    if( rval < 0 )
    {
        H5Gclose( tag_id );
        return;
    }
    is_handle = rval;
 
    /* Get tag type */
#if defined( H5Topen_vers ) && H5Topen_vers > 1
    type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
#else
    type_id = H5Topen( tag_id, TAG_TYPE_NAME );
#endif
    if( type_id < 0 )
    {
        H5Gclose( tag_id );
        mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
        return;
    }
 
    class_tmp = H5Tget_class( type_id );
    if( class_tmp < 0 )
    {
        mhdf_setFail( status, "H5Tget_class failed." );
        H5Gclose( tag_id );
        H5Tclose( type_id );
        return;
    }
 
    size = H5Tget_size( type_id );
    if( size <= 0 )
    {
        mhdf_setFail( status, "H5Tget_size failed." );
        H5Gclose( tag_id );
        H5Tclose( type_id );
        return;
    }
 
    switch( class_tmp )
    {
        case H5T_INTEGER:
            *class_out = ( size == 1 ) ? mhdf_BOOLEAN : mhdf_INTEGER;
            *size_out  = 1;
            break;
 
        case H5T_FLOAT:
            *class_out = mhdf_FLOAT;
            *size_out  = 1;
            break;
 
        case H5T_BITFIELD:
            *class_out = mhdf_BITFIELD;
            *size_out  = H5Tget_precision( type_id );
            if( *size_out <= 0 )
            {
                mhdf_setFail( status, "H5Tget_precision failed." );
                H5Gclose( tag_id );
                H5Tclose( type_id );
                return;
            }
            break;
 
        default:
        case H5T_OPAQUE:
            *class_out = mhdf_OPAQUE;
            *size_out  = size;
            break;
 
        case H5T_ARRAY:
 
#if defined( H5Tget_array_dims_vers ) && H5Tget_array_dims_vers > 1
            (void)perm; /* suppress warning */
            rank = H5Tget_array_dims2( type_id, dims );
#else
            rank      = H5Tget_array_dims( type_id, dims, perm );
#endif
            if( rank <= 0 )
            {
                mhdf_setFail( status, "H5Tget_size failed." );
                H5Gclose( tag_id );
                H5Tclose( type_id );
                return;
            }
            for( i = 1; i < rank; ++i )
                dims[0] *= dims[i];
 
            super_id = H5Tget_super( type_id );
            if( super_id < 0 )
            {
                mhdf_setFail( status, "H5Tget_super failed" );
                H5Gclose( tag_id );
                H5Tclose( type_id );
                return;
            }
 
            class_tmp = H5Tget_class( super_id );
            if( class_tmp < 0 )
            {
                mhdf_setFail( status, "H5Tget_class failed." );
                H5Gclose( tag_id );
                H5Tclose( type_id );
                H5Tclose( super_id );
                return;
            }
 
            sup_size = H5Tget_size( super_id );
            H5Tclose( super_id );
            if( sup_size <= 0 )
            {
                mhdf_setFail( status, "H5Tget_size failed." );
                H5Gclose( tag_id );
                H5Tclose( type_id );
                return;
            }
 
            switch( class_tmp )
            {
                case H5T_INTEGER:
                    *class_out = ( sup_size == 1 ) ? mhdf_BOOLEAN : mhdf_INTEGER;
                    *size_out  = dims[0];
                    break;
 
                case H5T_FLOAT:
                    *class_out = mhdf_FLOAT;
                    *size_out  = dims[0];
                    break;
 
                default:
                    *class_out = mhdf_OPAQUE;
                    *size_out  = size;
                    break;
            }
 
            break;
    }
    H5Tclose( type_id );
    H5Gclose( tag_id );
 
    if( is_handle )
    {
        if( *class_out != mhdf_INTEGER )
        {
            mhdf_setFail( status, "Non-integer tag marked as handle type." );
            return;
        }
        *class_out = mhdf_ENTITY_ID;
    }
 
    if( var_data )
    {
        if( *size_out != 1 || *class_out == mhdf_BITFIELD )
        {
            mhdf_setFail( status, "Invalid or unexpected variable-length tag data" );
            return;
        }
        *size_out = -1;
    }
 
    mhdf_setOkay( status );
    API_END;
}

References API_BEGIN, API_END, get_attrib_array_length_name(), get_tag(), mhdf_BITFIELD, mhdf_BOOLEAN, mhdf_ENTITY_ID, mhdf_find_attribute(), mhdf_FLOAT, mhdf_INTEGER, mhdf_is_in_group(), mhdf_OPAQUE, mhdf_read_scalar_attrib(), mhdf_setFail(), mhdf_setOkay(), size, SPARSE_ENTITY_NAME, TAG_DEFAULT_ATTRIB, TAG_GLOBAL_ATTRIB, TAG_HANDLE_TYPE_ATTRIB, TAG_TYPE_ATTRIB, TAG_TYPE_NAME, and TAG_VARLEN_ATTRIB.

Referenced by get_tag_desc(), and main().

mhdf_getTagNames()

char** mhdf_getTagNames	(	mhdf_FileHandle	file_handle,
		int *	num_names_out,
		mhdf_Status *	status
	)

Get the name for each tag defined in the file.

Parameters

file_handle	The file.
num_names_out	The length of the returned array of strings.
status	Passed back status of API call.

Returns

An array of null-terminated strings. The array and each string is allocated with malloc. The caller should release this memory by calling free for each string and the array.

Definition at line 655 of file tags.c.

{
    hid_t group_id;
    FileHandle* file_ptr;
    hsize_t count, idx;
    char* name;
    char** result;
    ssize_t size;
    API_BEGIN;
 
    /* Validate input */
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
 
        /* Open the tags group */
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
#else
    group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
#endif
    if( group_id < 0 )
    {
        mhdf_setFail( status, "H5Gopen(\"%s\") failed", TAG_GROUP );
        return NULL;
    }
 
    /* Get number of objects in tags group */
 
    if( H5Gget_num_objs( group_id, &count ) < 0 )
    {
        mhdf_setFail( status, "Internal failure calling H5Gget_num_objs." );
        H5Gclose( group_id );
        return NULL;
    }
 
    /* No tags? */
 
    *num_names_out = (int)count;
    if( count == 0 )
    {
        H5Gclose( group_id );
        mhdf_setOkay( status );
        return NULL;
    }
 
    /* Allocate string array */
 
    result = (char**)mhdf_malloc( sizeof( char* ) * count, status );
    if( NULL == result )
    {
        H5Gclose( group_id );
        return NULL;
    }
 
    /* Get names */
 
    for( idx = 0; idx < count; ++idx )
    {
        size = H5Gget_objname_by_idx( group_id, idx, NULL, 0 );
        if( size < 1 || NULL == ( name = (char*)mhdf_malloc( size + 1, status ) ) )
        {
            while( ( --idx ) > 0 )
                free( result[idx] );
            free( result );
            H5Gclose( group_id );
            mhdf_setFail( status, "Internal failure calling H5Gget_objname_by_idx." );
            return NULL;
        }
 
        H5Gget_objname_by_idx( group_id, idx, name, size + 1 );
        if( !mhdf_path_to_name( name, name ) )
        {
            mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name );
            return NULL;
        }
        result[idx] = name;
    }
 
    H5Gclose( group_id );
    mhdf_setOkay( status );
    API_END;
    return result;
}

References API_BEGIN, API_END, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_malloc(), mhdf_path_to_name(), mhdf_setFail(), mhdf_setOkay(), size, and TAG_GROUP.

Referenced by mhdf_getFileSummary().

mhdf_getTagValues()

void mhdf_getTagValues	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		hid_t	output_data_type,
		void *	default_value,
		void *	global_value,
		mhdf_Status *	status
	)

Get the default and global values of the tag.

Parameters

file_handle	The file.
tag_name	The tag name.
output_data_type	The HDF5 type for the memory into which the tag data is to be written. If zero, then the value(s) will be read as opaque data.
default_value	Memory location at which to write the default value of the tag.
global_value	If the tag has a global value, the memory location at which to write that value.
status	Passed back status of API call.

Definition at line 1135 of file tags.c.

{
    hid_t tag_id;
    int rval, var_data;
    unsigned int idx;
    API_BEGIN;
 
    /* check args */
    if( NULL == tag_name || !*tag_name )
    {
        mhdf_setFail( status, "Invalid input." );
        return;
    }
 
    /* Get the tag group */
    tag_id = get_tag( file_handle, tag_name, NULL, status );
    if( tag_id < 0 ) return;
 
    /* Check for variable-length tag data */
    rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
    if( rval < 0 )
    {
        H5Gclose( tag_id );
        return;
    }
    var_data = rval ? 1 : 0;
 
    /* Read default value if present */
    rval = read_tag_attrib_data( tag_id, TAG_DEFAULT_ATTRIB, output_data_type, default_value, var_data, status );
    if( !rval )
    {
        H5Gclose( tag_id );
        return;
    }
 
    /* Read mesh value if present */
    rval = read_tag_attrib_data( tag_id, TAG_GLOBAL_ATTRIB, output_data_type, global_value, var_data, status );
    if( !rval )
    {
        H5Gclose( tag_id );
        return;
    }
 
    H5Gclose( tag_id );
    mhdf_setOkay( status );
    API_END;
}

References API_BEGIN, API_END, get_tag(), mhdf_find_attribute(), mhdf_setFail(), mhdf_setOkay(), read_tag_attrib_data(), TAG_DEFAULT_ATTRIB, TAG_GLOBAL_ATTRIB, and TAG_VARLEN_ATTRIB.

Referenced by moab::ReadHDF5::create_tag(), and get_tag_desc().

mhdf_haveDenseTag()

int mhdf_haveDenseTag	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		const char *	elem_group,
		mhdf_Status *	status
	)

Check if the file contains dense tag data for the specified tag and element group.

Check if there is dense tag data for a given element type for the specified tag.

Parameters

file_handle	The file.
tag_name	The tag.
elem_group	The element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
status	Passed back status of API call.

Returns

Non-zero if file contains specified data. Zero otherwise.

Definition at line 1188 of file tags.c.

{
    char* path;
    hid_t elem_id, group_id;
    FileHandle* file_ptr;
    int rval = 0;
    API_BEGIN;
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
    if( type_handle == mhdf_node_type_handle() )
    {
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
        elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
#else
        elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
#endif
        if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
    }
    else if( type_handle == mhdf_set_type_handle() )
    {
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
        elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
#else
        elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
#endif
        if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
    }
    else
    {
        elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
    }
    if( elem_id < 0 ) return -1;
 
    rval = mhdf_is_in_group( elem_id, TAG_GROUP_NAME, status );
    if( rval < 0 )
    {
        H5Gclose( elem_id );
        return -1;
    }
    else if( rval == 0 )
    {
        H5Gclose( elem_id );
        mhdf_setOkay( status );
        return 0;
    }
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
    group_id = H5Gopen2( elem_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT );
#else
    group_id = H5Gopen( elem_id, DENSE_TAG_SUBGROUP );
#endif
    H5Gclose( elem_id );
    if( group_id < 0 )
    {
        mhdf_setFail( status, "Could not open tag subgroup." );
        return -1;
    }
 
    path = mhdf_name_to_path_copy( tag_name, status );
    if( NULL == path )
    {
        H5Gclose( group_id );
        return -1;
    }
 
    rval = mhdf_is_in_group( group_id, path, status );
    H5Gclose( group_id );
    free( path );
 
    if( rval >= 0 )
    {
        mhdf_setOkay( status );
    }
 
    API_END;
    return rval;
}

References API_BEGIN, API_END, DENSE_TAG_SUBGROUP, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_is_in_group(), mhdf_name_to_path_copy(), mhdf_node_type_handle(), mhdf_set_type_handle(), mhdf_setFail(), mhdf_setOkay(), NODE_GROUP, SET_GROUP, and TAG_GROUP_NAME.

Referenced by main(), and mhdf_getFileSummary().

mhdf_openDenseTagData()

hid_t mhdf_openDenseTagData	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		const char *	elem_group,
		long *	num_values_out,
		mhdf_Status *	status
	)

Open the object containing dense tag values for a given element group.

Parameters

file_handle	The file.
tag_name	The tag.
elem_group	The element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
num_values_out	The number of tag values to be written. Must be The same as the number of elements in the group.
status	Passed back status of API call.

Returns

Handle to data object in file.

Definition at line 1339 of file tags.c.

{
    char* path;
    hid_t elem_id, data_id;
    FileHandle* file_ptr;
    size_t name_len, path_len, dir_len;
    hsize_t size;
    API_BEGIN;
 
    file_ptr = (FileHandle*)file_handle;
    if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
    if( type_handle == mhdf_node_type_handle() )
    {
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
        elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
#else
        elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
#endif
        if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
    }
    else if( type_handle == mhdf_set_type_handle() )
    {
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
        elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
#else
        elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
#endif
        if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
    }
    else
    {
        elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
    }
    if( elem_id < 0 ) return -1;
 
    dir_len  = strlen( DENSE_TAG_SUBGROUP );
    name_len = mhdf_name_to_path( tag_name, NULL, 0 );
    path_len = dir_len + name_len + 1;
    path     = (char*)mhdf_malloc( path_len, status );
    if( NULL == path )
    {
        H5Gclose( elem_id );
        return -1;
    }
    strcpy( path, DENSE_TAG_SUBGROUP );
    mhdf_name_to_path( tag_name, path + dir_len, name_len + 1 );
 
    data_id = mhdf_open_table( elem_id, path, 1, &size, status );
    free( path );
    H5Gclose( elem_id );
    *num_values_out = (long)size;
 
    if( data_id >= 0 ) mhdf_setOkay( status );
 
    API_END_H( 1 );
    return data_id;
}

References API_BEGIN, API_END_H, DENSE_TAG_SUBGROUP, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_malloc(), mhdf_name_to_path(), mhdf_node_type_handle(), mhdf_open_table(), mhdf_set_type_handle(), mhdf_setFail(), mhdf_setOkay(), NODE_GROUP, SET_GROUP, and size.

Referenced by check_valid_tag(), main(), mhdf_getFileSummary(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::search_tag_values(), and moab::WriteHDF5::write_dense_tag().

mhdf_openSparseTagData()

void mhdf_openSparseTagData	(	mhdf_FileHandle	file_handle,
		const char *	tag_name,
		long *	num_entity_out,
		long *	num_values_out,
		hid_t	entities_and_values_out[3],
		mhdf_Status *	status
	)

Create file objects to read sparse tag data.

Open the file objects containing all sparse data for a given tag in. The sparse data is stored in a pair of objects. The first is a vector of global IDs. The second is a vector of tag values for each entity specified in the list of global IDs. For variable-length tags, a third table containing end offsets for each tag value is returned in the third position of the output hid_t array (see mhdf_readSparseTagIndices.)

Parameters

file_handle	The file.
tag_name	The tag.
num_entity_out	The number of entities for which there are tag values.
num_values_out	The number of data values. For fixed-length tags, this is the same as num_entity_out. For variable-length tags, it is the total number of values in the data table.
entities_and_values_out	The handles to the pair of file objects. The first is the vector of global IDs. The second is the list of corresponding tag values. The third is the handle to the index table, iff the tag is variable-length. If the tag is fixed-length, this value is not set.
status	Passed back status of API call.

Definition at line 1511 of file tags.c.

{
    hid_t tag_id, index_id, data_id, offset_id = -1;
    hsize_t num_ent, data_size, num_data;
    int rval;
    unsigned idx;
    API_BEGIN;
 
    tag_id = get_tag( file_handle, tag_name, NULL, status );
    if( tag_id < 0 ) return;
 
    index_id = mhdf_open_table( tag_id, SPARSE_ENTITY_NAME, 1, &num_ent, status );
    if( index_id < 0 )
    {
        H5Gclose( tag_id );
        return;
    }
 
    data_id = mhdf_open_table( tag_id, SPARSE_VALUES_NAME, 1, &data_size, status );
    if( data_id < 0 )
    {
        H5Gclose( tag_id );
        H5Dclose( index_id );
        return;
    }
 
    /* check if tag is variable-lentgth */
    rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
    if( rval < 0 )
    {
        H5Gclose( tag_id );
        H5Dclose( index_id );
        H5Dclose( data_id );
        return;
    }
 
    /* If variable length... */
    if( rval )
    {
        offset_id = mhdf_open_table( tag_id, TAG_VAR_INDICES, 1, &num_data, status );
        if( offset_id < 0 )
        {
            H5Gclose( tag_id );
            H5Dclose( index_id );
            H5Dclose( data_id );
            return;
        }
    }
    /* Otherwise the number of values is the same as the size of the data table */
    else
    {
        num_data = data_size;
    }
 
    H5Gclose( tag_id );
    if( num_ent != num_data )
    {
        mhdf_setFail( status, "Data length mismatch for sparse tag data -- invalid file." );
        if( offset_id >= 0 ) H5Dclose( offset_id );
        H5Dclose( index_id );
        H5Dclose( data_id );
        return;
    }
    *num_entity_out = (long)num_ent;
    if( num_values_out ) *num_values_out = (long)data_size;
 
    handles_out[0] = index_id;
    handles_out[1] = data_id;
    if( offset_id >= 0 ) handles_out[2] = offset_id;
    mhdf_setOkay( status );
    API_END_H( 2 );
}

References API_BEGIN, API_END_H, get_tag(), mhdf_find_attribute(), mhdf_open_table(), mhdf_setFail(), mhdf_setOkay(), SPARSE_ENTITY_NAME, SPARSE_VALUES_NAME, TAG_VAR_INDICES, and TAG_VARLEN_ATTRIB.

Referenced by check_valid_tag(), check_valid_var_len_tag(), moab::ReadHDF5::get_tagged_entities(), main(), mhdf_getFileSummary(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::search_tag_values(), moab::WriteHDF5::write_sparse_tag(), and moab::WriteHDF5::write_var_len_tag().

mhdf_readSparseTagEntities()

void mhdf_readSparseTagEntities	(	hid_t	id_handle,
		long	offset,
		long	count,
		hid_t	hdf_integer_type,
		void *	id_list,
		mhdf_Status *	status
	)

Read Global ID list for sparse tag data.

Parameters

id_handle	The first handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData.
offset	The offset at which to begin reading.
count	The number of global IDs to read.
hdf_integer_type	The type of the integer data in id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_list	The memory location at which to store the global IDs.
status	Passed back status of API call.

Definition at line 1660 of file tags.c.

{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_tag(), check_valid_var_len_tag(), and main().

mhdf_readSparseTagEntitiesWithOpt()

void mhdf_readSparseTagEntitiesWithOpt	(	hid_t	table_id,
		long	offset,
		long	count,
		hid_t	int_type,
		void *	id_list,
		hid_t	io_prop,
		mhdf_Status *	status
	)

Definition at line 1671 of file tags.c.

{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, int_type, id_list, io_prop, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by moab::ReadHDF5::get_tagged_entities(), and moab::ReadHDF5::search_tag_values().

mhdf_readSparseTagIndices()

void mhdf_readSparseTagIndices	(	hid_t	tag_handle,
		long	offset,
		long	count,
		hid_t	hdf_integer_type,
		void *	end_indices,
		mhdf_Status *	status
	)

Read sparse tag end indices for variable-length tag data.

Read sparse tag end indices for variable-length tag data. Each value in the list is the last index (zero-based) into the tag data for the corresponding entity.

Parameters

tag_handle	handle to the data object to read from.
offset	The offset into the table at which to begin reading
count	The number of values to read.
hdf_integer_type	The type of the values pointed to by end_indices (must be an integer type).
end_indices	Memory in which to store the data read from the table.
status	Output: API result.

Definition at line 1701 of file tags.c.

{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, int_type, indices, H5P_DEFAULT, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_var_len_tag().

mhdf_readSparseTagIndicesWithOpt()

void mhdf_readSparseTagIndicesWithOpt	(	hid_t	table_id,
		long	offset,
		long	count,
		hid_t	int_type,
		void *	indices,
		hid_t	io_prop,
		mhdf_Status *	status
	)

Definition at line 1712 of file tags.c.

{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, int_type, indices, io_prop, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_read_data().

mhdf_readTagValues()

void mhdf_readTagValues	(	hid_t	value_handle,
		long	offset,
		long	count,
		hid_t	hdf_type,
		void *	memory,
		mhdf_Status *	status
	)

Read tag values.

Parameters

value_handle	The second handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData; or the handle returned by mhdf_createDenseTagData or mhdf_openDenseTagData.
offset	The offset at which to begin reading.
count	The number of tag values to read.
hdf_type	The type of the data in memory. If this is specified, it must be possible for the HDF library to convert between this type and the type the tag data is stored as. If zero, the values will be read as opaque data.
memory	Memory location at which to store tag values.
status	Passed back status of API call.

Definition at line 1684 of file tags.c.

{
    mhdf_readTagValuesWithOpt( table_id, offset, count, tag_type, tag_data, H5P_DEFAULT, status );
}

References mhdf_readTagValuesWithOpt().

Referenced by check_valid_tag(), check_valid_var_len_tag(), and mhdf_getFileSummary().

mhdf_readTagValuesWithOpt()

void mhdf_readTagValuesWithOpt	(	hid_t	table_id,
		long	offset,
		long	count,
		hid_t	tag_type,
		void *	tag_data,
		hid_t	io_prop,
		mhdf_Status *	status
	)

Definition at line 1688 of file tags.c.

{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, tag_type, tag_data, io_prop, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by mhdf_readTagValues(), moab::ReadHDF5::read_tag_values_all(), and moab::ReadHDF5::search_tag_values().

mhdf_writeSparseTagEntities()

void mhdf_writeSparseTagEntities	(	hid_t	id_handle,
		long	offset,
		long	count,
		hid_t	hdf_integer_type,
		const void *	id_list,
		mhdf_Status *	status
	)

Write Global ID list for sparse tag data.

Parameters

id_handle	The first handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData.
offset	The offset at which to begin writing.
count	The number of global IDs to write.
hdf_integer_type	The type of the integer data in id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_list	The list of global IDs to write.
status	Passed back status of API call.

Definition at line 1589 of file tags.c.

{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_write_data().

mhdf_writeSparseTagEntitiesWithOpt()

void mhdf_writeSparseTagEntitiesWithOpt	(	hid_t	table_id,
		long	offset,
		long	count,
		hid_t	int_type,
		const void *	id_list,
		hid_t	io_prop,
		mhdf_Status *	status
	)

Definition at line 1600 of file tags.c.

{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, int_type, id_list, io_prop, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_sparse_ids().

mhdf_writeSparseTagIndices()

void mhdf_writeSparseTagIndices	(	hid_t	tag_handle,
		long	offset,
		long	count,
		hid_t	hdf_integer_type,
		const void *	end_indices,
		mhdf_Status *	status
	)

Write sparse tag end indices for variable-length tag data.

Write sparse tag end indices for variable-length tag data. Each value in the list is the last index (zero-based) into the tag data for the corresponding entity.

Parameters

tag_handle	handle to the data object to write to.
offset	The offset into the table at which to begin writting
count	The number of values to write.
hdf_integer_type	The type of the values pointed to by end_indices (must be an integer type).
end_indices	The values to store in the table.
status	Output: API result.

Definition at line 1636 of file tags.c.

{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, int_type, indices, H5P_DEFAULT, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_write_data().

mhdf_writeSparseTagIndicesWithOpt()

void mhdf_writeSparseTagIndicesWithOpt	(	hid_t	table_id,
		long	offset,
		long	count,
		hid_t	int_type,
		const void *	indices,
		hid_t	io_prop,
		mhdf_Status *	status
	)

Definition at line 1647 of file tags.c.

{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, int_type, indices, io_prop, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_var_len_indices().

mhdf_writeTagValues()

void mhdf_writeTagValues	(	hid_t	value_handle,
		long	offset,
		long	count,
		hid_t	hdf_tag_data_type,
		const void *	tag_data,
		mhdf_Status *	status
	)

Write tag values.

Parameters

value_handle	The second handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData; or the handle returned by mhdf_createDenseTagData or mhdf_openDenseTagData.
offset	The offset at which to begin writing.
count	The number of tag values to write.
hdf_tag_data_type	The type of the data in memory. It must be possible for the HDF library to convert between this type and the type the tag data is stored as.
tag_data	The list of tag values to write.
status	Passed back status of API call.

Definition at line 1613 of file tags.c.

{
    mhdf_writeTagValuesWithOpt( table_id, offset, count, tag_type, tag_data, H5P_DEFAULT, status );
}

References mhdf_writeTagValuesWithOpt().

mhdf_writeTagValuesWithOpt()

void mhdf_writeTagValuesWithOpt	(	hid_t	table_id,
		long	offset,
		long	count,
		hid_t	tag_type,
		const void *	tag_data,
		hid_t	io_prop,
		mhdf_Status *	status
	)

Definition at line 1623 of file tags.c.

{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, tag_type, tag_data, io_prop, status );
    API_END;
}

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by mhdf_writeTagValues(), moab::WriteHDF5::write_tag_values(), and moab::WriteHDF5::write_var_len_data().

read_tag_attrib_data()

static int read_tag_attrib_data ( hid_t  tag_id, const char *  attrib_name, hid_t  type_id, void *  data, int  is_var_len, mhdf_Status *  status  )

static

Definition at line 1075 of file tags.c.

{
    int rval, ilen;
    unsigned idx;
    hid_t read_type = type_id;
    hsize_t len;
 
    /* Check if tag has attribute */
    rval = mhdf_find_attribute( tag_id, attrib_name, &idx, status );
    if( rval < 0 )
        return 0;
    else if( 0 == rval )
        return 1;
 
    if( NULL == data )
    {
        mhdf_setFail( status, "Invalid input." );
        return 0;
    }
 
    if( is_var_len )
    {
        /* len = get_attrib_array_length_index(tag_id, index); */
        ilen = get_attrib_array_length_name( tag_id, attrib_name );
        if( ilen < 0 )
        {
            mhdf_setFail( status, "Failed to read length of default/mesh value for tag" );
            return 0;
        }
        len = ilen;
 
        /* caller passes type_id == 0 for OPAQUE */
        if( 0 == type_id )
            read_type = H5Tcreate( H5T_OPAQUE, len );
        else
        {
#if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
            read_type = H5Tarray_create2( type_id, 1, &len );
#else
            read_type = H5Tarray_create( type_id, 1, &len, 0 );
#endif
        }
        if( read_type < 0 )
        {
            mhdf_setFail( status, "Failed to read mesh/default value for tag" );
            return 0;
        }
    }
 
    rval = mhdf_read_scalar_attrib( tag_id, attrib_name, read_type, data, status );
    if( is_var_len ) H5Tclose( read_type );
 
    return rval;
}

References get_attrib_array_length_name(), mhdf_find_attribute(), mhdf_read_scalar_attrib(), and mhdf_setFail().

Referenced by mhdf_getTagValues().

store_tag_val_in_attrib()

static int store_tag_val_in_attrib ( hid_t  tag_id, const char *  attrib_name, hid_t  type_id, const void *  value, hsize_t  value_size, mhdf_Status *  status  )

static

Helper function to write default and mesh values for tag

Parameters

tag_id	The file object upon which to attach the attribute
attrib_name	The name of the attribute object
type_id	The data type of the attribute data
value	Pointer to attribute data
value_size	Size of attribute data, as multiple of type indicated by type_id. Should be 1 except for variable-length tag data.

Definition at line 199 of file tags.c.

{
    hid_t write_type;
    int rval;
    if( value_size == 1 )
        write_type = type_id;
    else if( H5Tget_class( type_id ) == H5T_OPAQUE )
    {
        write_type = H5Tcreate( H5T_OPAQUE, value_size );
    }
    else
    {
#if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
        write_type = H5Tarray_create2( type_id, 1, &value_size );
#else
        write_type = H5Tarray_create( type_id, 1, &value_size, 0 );
#endif
    }
 
    if( write_type < 0 )
    {
        mhdf_setFail( status, "Error constructing type object for tag mesh/default value" );
        return -1;
    }
 
    rval = mhdf_create_scalar_attrib( tag_id, attrib_name, write_type, value, status );
    if( write_type != type_id ) H5Tclose( write_type );
 
    return rval;
}

References mhdf_create_scalar_attrib(), and mhdf_setFail().

Referenced by create_tag_common().