sets.c

Go to the documentation of this file.

/**
 * 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.
 *
 */
 
#include <H5Tpublic.h>
#include <H5Dpublic.h>
#include <H5Gpublic.h>
#include <H5Spublic.h>
#include <H5Ppublic.h>
#include "mhdf.h"
#include "util.h"
#include "file-handle.h"
#include "status.h"
#include "names-and-paths.h"
 
int mhdf_haveSets( mhdf_FileHandle file, int* have_data, int* have_child, int* have_parent, mhdf_Status* status )
{
 FileHandle* file_ptr = (FileHandle*)file;
 hid_t root_id, set_id;
 int result;
 API_BEGIN;
 
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 root_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
#else
 root_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
#endif
 if( root_id < 0 )
 {
 mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", ROOT_GROUP );
 return -1;
 }
 
 result = mhdf_is_in_group( root_id, SET_GROUP_NAME, status );
 if( result < 1 )
 {
 H5Gclose( root_id );
 return result;
 }
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 set_id = H5Gopen2( root_id, SET_GROUP_NAME, H5P_DEFAULT );
#else
 set_id = H5Gopen( root_id, SET_GROUP_NAME );
#endif
 H5Gclose( root_id );
 if( set_id < 0 )
 {
 mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", SET_GROUP );
 return -1;
 }
 
 result = mhdf_is_in_group( set_id, SET_META_NAME, status );
 if( result < 0 )
 {
 H5Gclose( set_id );
 return result;
 }
 
 if( have_data )
 {
 *have_data = mhdf_is_in_group( set_id, SET_DATA_NAME, status );
 if( *have_data < 0 )
 {
 H5Gclose( set_id );
 return *have_data;
 }
 }
 
 if( have_child )
 {
 *have_child = mhdf_is_in_group( set_id, SET_CHILD_NAME, status );
 if( *have_child < 0 )
 {
 H5Gclose( set_id );
 return *have_child;
 }
 }
 
 if( have_parent )
 {
 *have_parent = mhdf_is_in_group( set_id, SET_PARENT_NAME, status );
 if( *have_parent < 0 )
 {
 H5Gclose( set_id );
 return *have_parent;
 }
 }
 
 mhdf_setOkay( status );
 H5Gclose( set_id );
 API_END;
 return result;
}
 
hid_t mhdf_createSetMeta( mhdf_FileHandle file, long num_sets, long* first_id_out, mhdf_Status* status )
{
 FileHandle* file_ptr = (FileHandle*)file;
 hid_t table_id;
 hsize_t dims[2];
 long first_id;
 API_BEGIN;
 
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 dims[0] = (hsize_t)num_sets;
 dims[1] = (hsize_t)4;
 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_META_PATH, MHDF_INDEX_TYPE, 2, dims, status );
 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 += num_sets;
 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;
}
 
hid_t mhdf_openSetMeta( mhdf_FileHandle file, long* num_sets, long* first_id_out, mhdf_Status* status )
{
 FileHandle* file_ptr = (FileHandle*)file;
 hid_t table_id;
 hsize_t dims[2];
 API_BEGIN;
 
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 table_id = mhdf_open_table2( file_ptr->hdf_handle, SET_META_PATH, 2, dims, first_id_out, status );
 if( table_id < 0 ) return -1;
 
 /* If dims[1] == 3, then old format of table.
 * Deal with it in mhdf_readSetMeta and mhdf_writeSetMeta
 */
 if( dims[1] != 4 && dims[1] != 3 )
 {
 mhdf_setFail( status, "Invalid format for meshset table.\n" );
 H5Dclose( table_id );
 return -1;
 }
 
 *num_sets = dims[0];
 file_ptr->open_handle_count++;
 mhdf_setOkay( status );
 API_END_H( 1 );
 return table_id;
}
 
hid_t mhdf_openSetMetaSimple( mhdf_FileHandle file, mhdf_Status* status )
{
 FileHandle* file_ptr = (FileHandle*)file;
 hid_t table_id;
 API_BEGIN;
 
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 table_id = mhdf_open_table_simple( file_ptr->hdf_handle, SET_META_PATH, status );
 if( table_id < 0 ) return -1;
 
 file_ptr->open_handle_count++;
 mhdf_setOkay( status );
 API_END_H( 1 );
 return table_id;
}
 
static int mhdf_readwriteSetMeta( hid_t table_id,
 int read,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 hid_t slab_id, sslab_id, smem_id, mem_id;
 hsize_t offsets[2], counts[2], mcounts[2], moffsets[2] = { 0, 0 };
 herr_t rval = 0;
 int dims, i;
 const int fill_val = -1;
 const hsize_t one = 1;
 
 mcounts[0] = count;
 mcounts[1] = 4;
 if( offset < 0 || count < 0 )
 {
 mhdf_setFail( status,
 "Invalid input for %s: "
 "offset = %ld, count = %ld\n",
 read ? "read" : "write", offset, count );
 return 0;
 }
 
 slab_id = H5Dget_space( table_id );
 if( slab_id < 0 )
 {
 mhdf_setFail( status, "Internal error calling H5Dget_space." );
 return 0;
 }
 
 dims = H5Sget_simple_extent_ndims( slab_id );
 if( dims != 2 )
 {
 H5Sclose( slab_id );
 mhdf_setFail( status, "Internal error: unexpected dataset rank: %d.", dims );
 return 0;
 }
 
 dims = H5Sget_simple_extent_dims( slab_id, counts, NULL );
 if( dims < 0 )
 {
 H5Sclose( slab_id );
 mhdf_setFail( status, "Internal error calling H5Sget_simple_extend_dims." );
 return 0;
 }
 
 if( (unsigned long)( offset + count ) > counts[0] )
 {
 H5Sclose( slab_id );
 mhdf_setFail( status, "Requested %s of rows %ld to %ld of a %ld row table.\n", read ? "read" : "write", offset,
 offset + count - 1, (long)counts[dims - 1] );
 return 0;
 }
 counts[0] = (hsize_t)count;
 offsets[0] = (hsize_t)offset;
 
 if( count )
 mem_id = H5Screate_simple( dims, mcounts, NULL );
 else
 { /* special case for 'NULL' read during collective parallel IO */
 mem_id = H5Screate_simple( 1, &one, NULL );
 if( mem_id && 0 > H5Sselect_none( mem_id ) )
 {
 H5Sclose( mem_id );
 mem_id = -1;
 }
 }
 if( mem_id < 0 )
 {
 mhdf_setFail( status, "Internal error calling H5Screate_simple." );
 return 0;
 }
 
 /* Normal table: 4 columns */
 if( counts[1] == 4 )
 {
 offsets[1] = 0;
 if( count )
 rval = H5Sselect_hyperslab( slab_id, H5S_SELECT_SET, offsets, NULL, counts, NULL );
 else /* special case for 'NULL' read during collective parallel IO */
 rval = H5Sselect_none( slab_id );
 if( rval < 0 )
 {
 H5Sclose( mem_id );
 H5Sclose( slab_id );
 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
 return 0;
 }
 
 if( read )
 rval = H5Dread( table_id, type, mem_id, slab_id, prop, data );
 else
 rval = H5Dwrite( table_id, type, mem_id, slab_id, prop, data );
 }
 /* Old table: 3 columns, no parent link counts */
 else if( counts[1] == 3 )
 {
 rval = 0;
 for( i = 0; i < 3 && rval >= 0; ++i )
 {
 smem_id = H5Scopy( mem_id );
 sslab_id = H5Scopy( slab_id );
 if( smem_id < 0 || sslab_id < 0 )
 {
 if( smem_id >= 0 ) H5Sclose( smem_id );
 mhdf_setFail( status, "Internal error calling H5Scopy." );
 return 0;
 }
 
 counts[1] = 1;
 offsets[1] = i;
 if( count )
 rval = H5Sselect_hyperslab( sslab_id, H5S_SELECT_SET, offsets, NULL, counts, NULL );
 else
 rval = H5Sselect_none( sslab_id );
 if( rval < 0 )
 {
 H5Sclose( slab_id );
 H5Sclose( mem_id );
 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
 return 0;
 }
 
 mcounts[1] = 1;
 moffsets[1] = ( i == 2 ) ? 3 : i;
 rval = H5Sselect_hyperslab( smem_id, H5S_SELECT_SET, moffsets, NULL, mcounts, NULL );
 if( rval < 0 )
 {
 H5Sclose( sslab_id );
 H5Sclose( slab_id );
 H5Sclose( mem_id );
 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
 return 0;
 }
 
 if( read )
 rval = H5Dread( table_id, type, smem_id, sslab_id, prop, data );
 else
 rval = H5Dwrite( table_id, type, smem_id, sslab_id, prop, data );
 
 H5Sclose( sslab_id );
 H5Sclose( smem_id );
 }
 
 if( read && rval >= 0 )
 {
 mcounts[1] = 1;
 moffsets[1] = 2;
 H5Sselect_hyperslab( mem_id, H5S_SELECT_SET, moffsets, NULL, mcounts, NULL );
 rval = H5Dfill( &fill_val, H5T_NATIVE_INT, data, type, mem_id );
 }
 }
 else
 {
 H5Sclose( mem_id );
 H5Sclose( slab_id );
 mhdf_setFail( status, "Invalid dimension for meshset metadata table." );
 return 0;
 }
 
 H5Sclose( slab_id );
 H5Sclose( mem_id );
 if( rval < 0 )
 {
 mhdf_setFail( status, "Internal error calling H5D%s.", read ? "read" : "write" );
 return 0;
 }
 
 mhdf_setOkay( status );
 return 1;
}
 
void mhdf_readSetMeta( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_readSetMetaWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, prop, status );
 API_END;
}
 
void mhdf_writeSetMeta( hid_t table_id, long offset, long count, hid_t type, const void* data, mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_writeSetMetaWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 const void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, prop, status );
 API_END;
}
 
enum SetMetaCol
{
 CONTENT = 0,
 CHILDREN = 1,
 PARENTS = 2,
 FLAGS = 3
};
 
static int mhdf_readSetMetaColumn( hid_t table_id,
 enum SetMetaCol column,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 hid_t slab_id, mem_id;
 hsize_t offsets[2], counts[2], mcount = count;
 herr_t rval = 0;
 int dims;
 const int fill_val = -1;
 
 if( offset < 0 || count < 0 )
 {
 mhdf_setFail( status,
 "Invalid input for reading set description column: "
 "offset = %ld, count = %ld\n",
 offset, count );
 return 0;
 }
 
 /* Get dimensions of table, and check against requested count and offset */
 
 slab_id = H5Dget_space( table_id );
 if( slab_id < 0 )
 {
 mhdf_setFail( status, "Internal error calling H5Dget_space." );
 return 0;
 }
 
 dims = H5Sget_simple_extent_ndims( slab_id );
 if( dims != 2 )
 {
 H5Sclose( slab_id );
 mhdf_setFail( status, "Internal error: unexpected dataset rank: %d.", dims );
 return 0;
 }
 
 dims = H5Sget_simple_extent_dims( slab_id, counts, NULL );
 if( dims < 0 )
 {
 H5Sclose( slab_id );
 mhdf_setFail( status, "Internal error calling H5Sget_simple_extend_dims." );
 return 0;
 }
 
 if( (unsigned long)( offset + count ) > counts[0] )
 {
 H5Sclose( slab_id );
 mhdf_setFail( status, "Requested read of rows %ld to %ld of a %ld row table.\n", offset, offset + count - 1,
 (long)counts[0] );
 return 0;
 }
 
 /* Create a slab definition for the block of memory we're reading into */
 
 mem_id = H5Screate_simple( 1, &mcount, NULL );
 if( mem_id < 0 )
 {
 H5Sclose( slab_id );
 mhdf_setFail( status, "Internal error calling H5Screate_simple." );
 return 0;
 }
 
 /* Old, 3-column table.
 * New table is {contents, children, parents, flags}
 * Old table is {contents, children, flags}
 * If asking for parents, just return zeros.
 * If asking for flags, fix column value.
 */
 offsets[1] = column;
 if( counts[1] == 3 )
 {
 if( column == PARENTS )
 {
 rval = H5Dfill( &fill_val, H5T_NATIVE_INT, data, type, mem_id );
 H5Sclose( mem_id );
 H5Sclose( slab_id );
 if( rval < 0 )
 {
 mhdf_setFail( status, "Internal error calling H5Dfill" );
 return 0;
 }
 else
 {
 mhdf_setOkay( status );
 return 1;
 }
 }
 else if( column == FLAGS )
 --offsets[1];
 }
 else if( counts[1] != 4 )
 {
 H5Sclose( mem_id );
 H5Sclose( slab_id );
 mhdf_setFail( status, "Invalid dimension for meshset metadata table." );
 return 0;
 }
 
 /* Create a slab defintion for the portion of the table we want to read. */
 
 /* offsets[1] was initialized in the above block of code. */
 offsets[0] = (hsize_t)offset;
 counts[0] = (hsize_t)count;
 counts[1] = 1; /* one column */
 if( count )
 rval = H5Sselect_hyperslab( slab_id, H5S_SELECT_SET, offsets, NULL, counts, NULL );
 else
 rval = H5Sselect_none( slab_id );
 if( rval < 0 )
 {
 H5Sclose( mem_id );
 H5Sclose( slab_id );
 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
 return 0;
 }
 
 /* Read the data */
 
 rval = H5Dread( table_id, type, mem_id, slab_id, prop, data );
 H5Sclose( mem_id );
 H5Sclose( slab_id );
 if( rval < 0 )
 {
 mhdf_setFail( status, "Internal error calling H5Dread." );
 return 0;
 }
 
 mhdf_setOkay( status );
 return 1;
}
 
void mhdf_readSetFlags( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_readSetFlagsWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, prop, status );
 API_END;
}
 
void mhdf_readSetContentEndIndices( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_readSetContentEndIndicesWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, prop, status );
 API_END;
}
 
void mhdf_readSetChildEndIndices( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_readSetChildEndIndicesWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, prop, status );
 API_END;
}
 
void mhdf_readSetParentEndIndices( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_readSetParentEndIndicesWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, prop, status );
 API_END;
}
 
hid_t mhdf_createSetData( mhdf_FileHandle file_handle, long data_list_size, mhdf_Status* status )
{
 FileHandle* file_ptr;
 hid_t table_id;
 hsize_t dim = (hsize_t)data_list_size;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 if( data_list_size < 1 )
 {
 mhdf_setFail( status, "Invalid argument.\n" );
 return -1;
 }
 
 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_DATA_PATH, file_ptr->id_type, 1, &dim, status );
 
 API_END_H( 1 );
 return table_id;
}
 
hid_t mhdf_openSetData( mhdf_FileHandle file_handle, long* data_list_size_out, mhdf_Status* status )
{
 FileHandle* file_ptr;
 hid_t table_id;
 hsize_t dim;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 if( !data_list_size_out )
 {
 mhdf_setFail( status, "Invalid argument.\n" );
 return -1;
 }
 
 table_id = mhdf_open_table( file_ptr->hdf_handle, SET_DATA_PATH, 1, &dim, status );
 
 *data_list_size_out = (long)dim;
 API_END_H( 1 );
 return table_id;
}
 
void mhdf_writeSetData( hid_t table_id, long offset, long count, hid_t type, const void* data, mhdf_Status* status )
{
 API_BEGIN;
 mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_writeSetDataWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 const void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_write_data( table_id, offset, count, type, data, prop, status );
 API_END;
}
 
void mhdf_readSetData( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
{
 API_BEGIN;
 mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_readSetDataWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_read_data( table_id, offset, count, type, data, prop, status );
 API_END;
}
 
hid_t mhdf_createSetChildren( mhdf_FileHandle file_handle, long child_list_size, mhdf_Status* status )
{
 FileHandle* file_ptr;
 hid_t table_id;
 hsize_t dim = (hsize_t)child_list_size;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 if( child_list_size < 1 )
 {
 mhdf_setFail( status, "Invalid argument.\n" );
 return -1;
 }
 
 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_CHILD_PATH, file_ptr->id_type, 1, &dim, status );
 
 API_END_H( 1 );
 return table_id;
}
 
hid_t mhdf_openSetChildren( mhdf_FileHandle file_handle, long* child_list_size, mhdf_Status* status )
{
 FileHandle* file_ptr;
 hid_t table_id;
 hsize_t dim;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 if( !child_list_size )
 {
 mhdf_setFail( status, "Invalid argument.\n" );
 return -1;
 }
 
 table_id = mhdf_open_table( file_ptr->hdf_handle, SET_CHILD_PATH, 1, &dim, status );
 
 *child_list_size = (long)dim;
 API_END_H( 1 );
 return table_id;
}
 
hid_t mhdf_createSetParents( mhdf_FileHandle file_handle, long parent_list_size, mhdf_Status* status )
{
 FileHandle* file_ptr;
 hid_t table_id;
 hsize_t dim = (hsize_t)parent_list_size;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 if( parent_list_size < 1 )
 {
 mhdf_setFail( status, "Invalid argument.\n" );
 return -1;
 }
 
 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_PARENT_PATH, file_ptr->id_type, 1, &dim, status );
 
 API_END_H( 1 );
 return table_id;
}
 
hid_t mhdf_openSetParents( mhdf_FileHandle file_handle, long* parent_list_size, mhdf_Status* status )
{
 FileHandle* file_ptr;
 hid_t table_id;
 hsize_t dim;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 if( !parent_list_size )
 {
 mhdf_setFail( status, "Invalid argument.\n" );
 return -1;
 }
 
 table_id = mhdf_open_table( file_ptr->hdf_handle, SET_PARENT_PATH, 1, &dim, status );
 
 *parent_list_size = (long)dim;
 API_END_H( 1 );
 return table_id;
}
 
void mhdf_writeSetParentsChildren( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 const void* data,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_writeSetParentsChildrenWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 const void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_write_data( table_id, offset, count, type, data, prop, status );
 API_END;
}
 
void mhdf_readSetParentsChildren( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
{
 API_BEGIN;
 mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
 API_END;
}
void mhdf_readSetParentsChildrenWithOpt( hid_t table_id,
 long offset,
 long count,
 hid_t type,
 void* data,
 hid_t prop,
 mhdf_Status* status )
{
 API_BEGIN;
 mhdf_read_data( table_id, offset, count, type, data, prop, status );
 API_END;
}