hid_t mhdf_openConnectivitySimple( mhdf_FileHandle file_handle, const char* elem_handle, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, table_id; API_BEGIN; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return -1; elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status ); if (elem_id < 0) return -1; table_id = mhdf_open_table_simple( elem_id, CONNECTIVITY_NAME, status ); H5Gclose( elem_id ); if (table_id < 0) return -1; file_ptr->open_handle_count++; mhdf_setOkay( status ); API_END_H(1); return table_id; }
void mhdf_closeData( mhdf_FileHandle file, hid_t handle, mhdf_Status* status ) { FileHandle* file_ptr; herr_t rval = -1; file_ptr = (FileHandle*)(file); if (!mhdf_check_valid_file( file_ptr, status )) return; switch ( H5Iget_type( handle ) ) { case H5I_GROUP : rval = H5Gclose( handle ); break; case H5I_DATATYPE : rval = H5Tclose( handle ); break; case H5I_DATASPACE: rval = H5Sclose( handle ); break; case H5I_DATASET : rval = H5Dclose( handle ); break; default : rval = -1; } if (rval < 0) { mhdf_setFail( status, "H5Xclose failed. Invalid handle?\n"); } else { file_ptr->open_handle_count--; mhdf_setOkay( status ); } }
void mhdf_closeFile( mhdf_FileHandle handle, mhdf_Status* status ) { FileHandle* file_ptr; API_BEGIN; file_ptr = (FileHandle*)(handle); if (!mhdf_check_valid_file( file_ptr, status )) return; /* if (file_ptr->open_handle_count) { mhdf_setError( status, "Cannot close file with %d open data handles.", file_ptr->open_handle_count ); return; } */ /* Check for open handles. HDF5 will not actually close the file until all handles are closed. */ if (mhdf_checkOpenHandles( handle, status )) return; if (0 > H5Fclose( file_ptr->hdf_handle )) { mhdf_setFail( status, "H5FClose failed. Invalid handle?" ); return; } memset( file_ptr, 0, sizeof(FileHandle) ); free( file_ptr ); mhdf_setOkay( status ); API_END_H( -1 ); }
int mhdf_checkOpenHandles( mhdf_FileHandle handle, mhdf_Status* status ) { FileHandle* file_ptr; int result; API_BEGIN; file_ptr = (FileHandle*)(handle); if (!mhdf_check_valid_file( file_ptr, status )) return -1; /* Check for open handles. HDF5 will not actually close the file until all handles are closed. */ result = H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ALL ); if (result != 1) { mhdf_setFail( status, "Cannot close file with open handles: " "%d file, %d data, %d group, %d type, %d attr\n", H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_FILE ) - 1, H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATASET ), H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_GROUP ), H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATATYPE ), H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ATTR ) ); return result - 1; } API_END_H( 0 ); return 0; }
void mhdf_openPolyConnectivity( mhdf_FileHandle file_handle, const char* element_handle, long* num_poly_out, long* data_list_length_out, long* first_poly_id_out, hid_t handles_out[2], mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, table_id, index_id; hsize_t row_count; API_BEGIN; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return ; if (!num_poly_out || !data_list_length_out || !first_poly_id_out) { mhdf_setFail( status, "Invalid argument." ); return ; } elem_id = mhdf_elem_group_from_handle( file_ptr, element_handle, status ); if (elem_id < 0) return ; index_id = mhdf_open_table( elem_id, POLY_INDEX_NAME, 1, &row_count, status ); if (index_id < 0) { H5Gclose(elem_id); return ; } *num_poly_out = (int)row_count; table_id = mhdf_open_table( elem_id, CONNECTIVITY_NAME, 1, &row_count, status ); H5Gclose( elem_id ); if (table_id < 0) { H5Dclose( index_id ); return ; } *data_list_length_out = (long)row_count; if (!mhdf_read_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, first_poly_id_out, status )) { H5Dclose( table_id ); H5Dclose( index_id ); return ; } file_ptr->open_handle_count++; handles_out[0] = index_id; handles_out[1] = table_id; mhdf_setOkay( status ); API_END_H(2); }
void mhdf_writeHistory( mhdf_FileHandle file_handle, const char** strings, int num_strings, mhdf_Status* status ) { FileHandle* file_ptr; hid_t data_id, type_id, space_id; hsize_t dim = (hsize_t)num_strings; herr_t rval; API_BEGIN; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return; type_id = H5Tcopy( H5T_C_S1 ); if (type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0) { if (type_id >= 0) H5Tclose(type_id); mhdf_setFail( status, "Could not create variable length string type." ); return; } space_id = H5Screate_simple( 1, &dim, NULL ); if (space_id < 0) { H5Tclose( type_id ); mhdf_setFail( status, "H5Screate_simple failed." ); return; } #if defined(H5Dcreate_vers) && H5Dcreate_vers > 1 data_id = H5Dcreate2( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); #else data_id = H5Dcreate( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT ); #endif H5Sclose( space_id ); if (data_id < 0) { H5Tclose( type_id ); mhdf_setFail( status, "Failed to create \"%s\".", HISTORY_PATH ); return; } rval = H5Dwrite( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, strings ); H5Dclose( data_id ); H5Tclose( type_id ); if (rval < 0) { H5Gunlink( file_ptr->hdf_handle, HISTORY_PATH ); mhdf_setFail( status, "Failed to write history data." ); return; } mhdf_setOkay( status ); API_END; }
void mhdf_getElemTypeName( mhdf_FileHandle file_handle, const char* elem_handle, char* buffer, size_t buf_len, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, type_id, attr_id; char bytes[16]; herr_t rval; API_BEGIN; if (NULL == buffer || buf_len < 2) { mhdf_setFail( status, "invalid input" ); return; } buffer[0] = '\0'; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return; elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status ); if (elem_id < 0) return; attr_id = H5Aopen_name( elem_id, ELEM_TYPE_ATTRIB ); H5Gclose( elem_id ); if (attr_id < 0) { mhdf_setFail( status, "Missing element type attribute. Invalid file." ); return; } type_id = H5Aget_type( attr_id ); assert( type_id > 0 ); rval = H5Aread( attr_id, type_id, bytes ); H5Aclose( attr_id ); if (rval < 0) { H5Tclose( type_id ); mhdf_setFail( status, "Failed to read element type attribute. Invalid file." ); return; } rval = H5Tenum_nameof( type_id, bytes, buffer, buf_len ); H5Tclose( type_id ); if (rval < 0) { mhdf_setFail( status, "Invalid datatype for element type attribute. Invalid file." ); return; } mhdf_setOkay( status ); API_END; return ; }
void mhdf_getNextStartId( mhdf_FileHandle file, mhdf_index_t* start_id_out, mhdf_Status* status ) { FileHandle* file_ptr = (FileHandle*)file; API_BEGIN; mhdf_setOkay( status ); if (mhdf_check_valid_file( file_ptr, status )) *start_id_out = file_ptr->max_id+1; API_END; }
hid_t mhdf_createAdjacency( mhdf_FileHandle file, const char* elem_handle, long adj_list_size, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, table_id; hsize_t dim = (hsize_t)adj_list_size; API_BEGIN; file_ptr = (FileHandle*)(file); if (!mhdf_check_valid_file( file_ptr, status )) return -1; if (adj_list_size < 1) { mhdf_setFail( status, "Invalid argument.\n" ); return -1; } if (elem_handle == mhdf_node_type_handle()) { table_id = mhdf_create_table( file_ptr->hdf_handle, NODE_ADJCY_PATH, file_ptr->id_type, 1, &dim, status ); } else { elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status ); if (elem_id < 0) return -1; table_id = mhdf_create_table( elem_id, ADJACENCY_NAME, file_ptr->id_type, 1, &dim, status ); H5Gclose( elem_id ); } API_END_H(1); return table_id; }
void mhdf_getElemName( mhdf_FileHandle file_handle, unsigned int type_index, char* buffer, size_t buf_size, mhdf_Status* status ) { FileHandle* file_ptr; herr_t rval; hid_t enum_id; API_BEGIN; if (type_index > 255) { mhdf_setFail( status, "Type index out of bounds." ); return; } file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return; enum_id = get_elem_type_enum( file_ptr, status ); if (enum_id < 0) return; rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super(enum_id), 1, &type_index, NULL, H5P_DEFAULT ); if (rval < 0) { H5Tclose( enum_id ); mhdf_setFail( status, "Internal error converting to enum type." ); return; } rval = H5Tenum_nameof( enum_id, &type_index, buffer, buf_size ); H5Tclose( enum_id ); if (rval < 0) mhdf_setFail( status, "H5Tenum_nameof failed. Invalid type index?" ); else mhdf_setOkay( status ); API_END; }
hid_t mhdf_openConnectivity( mhdf_FileHandle file_handle, const char* elem_handle, int* num_nodes_per_elem_out, long* num_elements_out, long* first_elem_id_out, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, table_id; hsize_t dims[2]; API_BEGIN; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return -1; if (!num_nodes_per_elem_out || !num_elements_out || !first_elem_id_out) { mhdf_setFail( status, "Invalid argument." ); return -1; } elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status ); if (elem_id < 0) return -1; table_id = mhdf_open_table2( elem_id, CONNECTIVITY_NAME, 2, dims, first_elem_id_out, status ); H5Gclose( elem_id ); if (table_id < 0) return -1; *num_elements_out = dims[0]; *num_nodes_per_elem_out = dims[1]; file_ptr->open_handle_count++; mhdf_setOkay( status ); API_END_H(1); return table_id; }
int mhdf_haveAdjacency( mhdf_FileHandle file, const char* elem_group, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id; int result; API_BEGIN; file_ptr = (FileHandle*)(file); if (!mhdf_check_valid_file( file_ptr, status )) return -1; if (elem_group == mhdf_node_type_handle()) { #if defined(H5Gopen_vers) && H5Gopen_vers > 1 elem_id = H5Gopen( 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, "H5Gopen( \"%s\" ) failed.\n", NODE_GROUP ); return -1; } } else { elem_id = mhdf_elem_group_from_handle( file_ptr, elem_group, status ); if (elem_id < 0) return -1; } result = mhdf_is_in_group( elem_id, ADJACENCY_NAME, status ); H5Gclose( elem_id ); mhdf_setOkay( status ); API_END; return result; }
int mhdf_isPolyElement( mhdf_FileHandle file_handle, const char* elem_handle, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id; int rval; API_BEGIN; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return -1; elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status ); if (elem_id < 0) return -1; mhdf_setOkay( status ); rval = mhdf_is_in_group( elem_id, POLY_INDEX_NAME, status ); H5Gclose( elem_id ); API_END; return rval; }
hid_t mhdf_createConnectivity( mhdf_FileHandle file_handle, const char* elem_handle, int nodes_per_elem, long count, long* first_id_out, mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, table_id; hsize_t dims[2]; long first_id; API_BEGIN; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return -1; if (nodes_per_elem <= 0 || count < 0 || !first_id_out) { mhdf_setFail( status, "Invalid argument." ); return -1; } elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status ); if (elem_id < 0) return -1; dims[0] = (hsize_t)count; dims[1] = (hsize_t)nodes_per_elem; table_id = mhdf_create_table( elem_id, CONNECTIVITY_NAME, file_ptr->id_type, 2, dims, status ); H5Gclose( elem_id ); if (table_id < 0) return -1; first_id = file_ptr->max_id + 1; if (!mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status )) { H5Dclose( table_id ); return -1; } *first_id_out = first_id; file_ptr->max_id += count; if (!mhdf_write_max_id( file_ptr, status)) { H5Dclose( table_id ); return -1; } file_ptr->open_handle_count++; mhdf_setOkay( status ); API_END_H(1); return table_id; }
void mhdf_createPolyConnectivity( mhdf_FileHandle file_handle, const char* elem_type, long num_poly, long data_list_length, long* first_id_out, hid_t handles_out[2], mhdf_Status* status ) { FileHandle* file_ptr; hid_t elem_id, index_id, conn_id; hsize_t dim; long first_id; API_BEGIN; file_ptr = (FileHandle*)(file_handle); if (!mhdf_check_valid_file( file_ptr, status )) return; if (num_poly <= 0 || data_list_length <= 0 || !first_id_out) { mhdf_setFail( status, "Invalid argument." ); return; } if (data_list_length < 3*num_poly) { /* Could check agains 4*num_poly, but allow degenerate polys (1 for count plus 2 dim-1 defining entities, where > 2 defining entities is a normal poly, 2 defining entities is a degenerate poly and 1 defning entity is not valid.) */ mhdf_setFail( status, "Invalid polygon data: data length of %ld is " "insufficient for %ld poly(gons/hedra).\n", data_list_length, num_poly ); return; } elem_id = mhdf_elem_group_from_handle( file_ptr, elem_type, status ); if (elem_id < 0) return; dim = (hsize_t)num_poly; index_id = mhdf_create_table( elem_id, POLY_INDEX_NAME, MHDF_INDEX_TYPE, 1, &dim, status ); if (index_id < 0) { H5Gclose(elem_id); return; } dim = (hsize_t)data_list_length; conn_id = mhdf_create_table( elem_id, CONNECTIVITY_NAME, file_ptr->id_type, 1, &dim, status ); H5Gclose( elem_id ); if (conn_id < 0) { H5Dclose(index_id); return; } first_id = file_ptr->max_id + 1; if (!mhdf_create_scalar_attrib( conn_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status )) { H5Dclose(index_id); H5Dclose( conn_id ); return; } *first_id_out = first_id; file_ptr->max_id += num_poly; if (!mhdf_write_max_id( file_ptr, status)) { H5Dclose(index_id); H5Dclose( conn_id ); return; } file_ptr->open_handle_count++; mhdf_setOkay( status ); handles_out[0] = index_id; handles_out[1] = conn_id; API_END_H(2); }
void mhdf_addElement( mhdf_FileHandle file_handle, const char* name, unsigned int elem_type, mhdf_Status* status ) { FileHandle* file_ptr = (FileHandle*)file_handle; hid_t group_id, tag_id, enum_id; char* path, *ptr; size_t name_len; herr_t rval; API_BEGIN; if (!mhdf_check_valid_file( file_ptr, status )) return; name_len = mhdf_name_to_path( name, NULL, 0 ); name_len += strlen(ELEMENT_GROUP) + 1; path = (char*)mhdf_malloc( name_len, status ); if (!path) return; strcpy( path, ELEMENT_GROUP ); ptr = path + strlen(ELEMENT_GROUP); if (!mhdf_path_to_name( name, ptr )) { mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name ); return; } #if defined(H5Gcreate_vers) && H5Gcreate_vers > 1 group_id = H5Gcreate2( file_ptr->hdf_handle, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); #else group_id = H5Gcreate( file_ptr->hdf_handle, path, 3 ); #endif if (group_id < 0) { mhdf_setFail( status, "Creation of \"%s\" group failed.\n", path ); free( path ); return; } free( path ); #if defined(H5Gcreate_vers) && H5Gcreate_vers > 1 tag_id = H5Gcreate2( group_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ); #else tag_id = H5Gcreate( group_id, DENSE_TAG_SUBGROUP, 0 ); #endif if (tag_id < 0) { H5Gclose( group_id ); mhdf_setFail( status, "Creation of tag subgroup failed.\n" ); return; } H5Gclose( tag_id ); enum_id = get_elem_type_enum( file_ptr, status ); if (enum_id < 0) { H5Gclose( group_id ); return; } rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super(enum_id), 1, &elem_type, NULL, H5P_DEFAULT ); if (rval < 0) { H5Gclose( group_id ); H5Tclose( enum_id ); mhdf_setFail( status, "Internal error converting to enum type." ); return; } rval = mhdf_create_scalar_attrib( group_id, ELEM_TYPE_ATTRIB, enum_id, &elem_type, status ); H5Tclose( enum_id ); if (rval < 0) { H5Gclose( group_id ); return; } H5Gclose( group_id ); mhdf_setOkay( status ); API_END; }