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;
}
int
main (void)
{
hid_t file, filetype, memtype, space, dset;
/* Handles */
herr_t status;
hsize_t dims[2] = {DIM0, DIM1};
phase_t wdata[DIM0][DIM1], /* Write buffer */
**rdata, /* Read buffer */
val;
char *names[4] = {"SOLID", "LIQUID", "GAS", "PLASMA"},
name[NAME_BUF_SIZE];
int ndims,
i, j;
/*
* Initialize data.
*/
for (i=0; i<DIM0; i++)
for (j=0; j<DIM1; j++)
wdata[i][j] = (phase_t) ( (i + 1) * j - j) % (int) (PLASMA + 1);
/*
* Create a new file using the default properties.
*/
file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create the enumerated datatypes for file and memory. This
* process is simplified if native types are used for the file,
* as only one type must be defined.
*/
filetype = H5Tenum_create (F_BASET);
memtype = H5Tenum_create (M_BASET);
for (i = (int) SOLID; i <= (int) PLASMA; i++) {
/*
* Insert enumerated value for memtype.
*/
val = (phase_t) i;
status = H5Tenum_insert (memtype, names[i], &val);
/*
* Insert enumerated value for filetype. We must first convert
* the numerical value val to the base type of the destination.
*/
status = H5Tconvert (M_BASET, F_BASET, 1, &val, NULL, H5P_DEFAULT);
status = H5Tenum_insert (filetype, names[i], &val);
}
/*
* Create dataspace. Setting maximum size to NULL sets the maximum
* size to be the current size.
*/
space = H5Screate_simple (2, dims, NULL);
/*
* Create the dataset and write the enumerated data to it.
*/
dset = H5Dcreate (file, DATASET, filetype, space, H5P_DEFAULT, H5P_DEFAULT,
H5P_DEFAULT);
status = H5Dwrite (dset, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata[0]);
/*
* Close and release resources.
*/
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (filetype);
status = H5Fclose (file);
/*
* Now we begin the read section of this example. Here we assume
* the dataset has the same name and rank, but can have any size.
* Therefore we must allocate a new array to read in data using
* malloc(). For simplicity, we do not rebuild memtype.
*/
/*
* Open file and dataset.
*/
file = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
dset = H5Dopen (file, DATASET, H5P_DEFAULT);
/*
* Get dataspace and allocate memory for read buffer. This is a
* two dimensional dataset so the dynamic allocation must be done
* in steps.
*/
space = H5Dget_space (dset);
ndims = H5Sget_simple_extent_dims (space, dims, NULL);
/*
* Allocate array of pointers to rows.
*/
rdata = (phase_t **) malloc (dims[0] * sizeof (phase_t *));
/*
* Allocate space for enumerated data.
*/
rdata[0] = (phase_t *) malloc (dims[0] * dims[1] * sizeof (phase_t));
/*
* Set the rest of the pointers to rows to the correct addresses.
*/
for (i=1; i<dims[0]; i++)
rdata[i] = rdata[0] + i * dims[1];
/*
* Read the data.
*/
status = H5Dread (dset, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata[0]);
/*
* Output the data to the screen.
*/
printf ("%s:\n", DATASET);
for (i=0; i<dims[0]; i++) {
printf (" [");
for (j=0; j<dims[1]; j++) {
/*
* Get the name of the enumeration member.
*/
status = H5Tenum_nameof (memtype, &rdata[i][j], name,
NAME_BUF_SIZE);
printf (" %-6s", name);
}
printf ("]\n");
}
/*
* Close and release resources.
*/
free (rdata[0]);
free (rdata);
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (memtype);
status = H5Fclose (file);
return 0;
}
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;
}
/*
* test_strpad
* Tests string padding for a UTF-8 string.
* Converts strings to shorter and then longer strings.
* Borrows heavily from dtypes.c, but is more complicated because
* the string is randomly generated.
*/
void test_strpad(hid_t UNUSED fid, const char *string)
{
/* buf is used to hold the data that H5Tconvert operates on. */
char buf[LONG_BUF_SIZE];
/* cmpbuf holds the output that H5Tconvert should produce,
* to compare against the actual output. */
char cmpbuf[LONG_BUF_SIZE];
/* new_string is a slightly modified version of the UTF-8
* string to make the tests run more smoothly. */
char new_string[MAX_STRING_LENGTH + 2];
size_t length; /* Length of new_string in bytes */
size_t small_len; /* Size of the small datatype */
size_t big_len; /* Size of the larger datatype */
hid_t src_type, dst_type;
herr_t ret;
/* The following tests are simpler if the UTF-8 string contains
* the right number of bytes (even or odd, depending on the test).
* We create a 'new_string' whose length is convenient by prepending
* an 'x' to 'string' when necessary. */
length = HDstrlen(string);
if(length % 2 != 1)
{
HDstrcpy(new_string, "x");
HDstrcat(new_string, string);
length++;
} else {
HDstrcpy(new_string, string);
}
/* Convert a null-terminated string to a shorter and longer null
* terminated string. */
/* Create a src_type that holds the UTF-8 string and its final NULL */
big_len = length + 1; /* +1 byte for final NULL */
HDassert((2*big_len)<=sizeof(cmpbuf));
src_type = mkstr(big_len, H5T_STR_NULLTERM);
CHECK(src_type, FAIL, "mkstr");
/* Create a dst_type that holds half of the UTF-8 string and a final
* NULL */
small_len = (length + 1) / 2;
dst_type = mkstr(small_len, H5T_STR_NULLTERM);
CHECK(dst_type, FAIL, "mkstr");
/* Fill the buffer with two copies of the UTF-8 string, each with a
* terminating NULL. It will look like "abcdefg\0abcdefg\0". */
strncpy(buf, new_string, big_len);
strncpy(&buf[big_len], new_string, big_len);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
* "abc\0abc\0abcdefg\0". Note that this is just what the bytes look
* like; UTF-8 characters may well have been truncated.
* To check that the conversion worked properly, we'll build this
* string manually. */
HDstrncpy(cmpbuf, new_string, small_len - 1);
cmpbuf[small_len - 1] = '\0';
HDstrncpy(&cmpbuf[small_len], new_string, small_len -1);
cmpbuf[2 * small_len - 1] = '\0';
HDstrcpy(&cmpbuf[2 * small_len], new_string);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abc\0\0\0\0\0abc\0\0\0\0\0" */
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with NULLs */
HDmemset(cmpbuf, '\0', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len -1);
HDstrncpy(&cmpbuf[big_len], new_string, small_len -1);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
ret = H5Tclose(src_type);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Tclose(dst_type);
CHECK(ret, FAIL, "H5Tclose");
/* Now test null padding. Null-padded strings do *not* need
* terminating NULLs, so the sizes of the datatypes are slightly
* different and we want a string with an even number of characters. */
length = HDstrlen(string);
if(length % 2 != 0)
{
HDstrcpy(new_string, "x");
HDstrcat(new_string, string);
length++;
} else {
HDstrcpy(new_string, string);
}
/* Create a src_type that holds the UTF-8 string */
big_len = length;
HDassert((2*big_len)<=sizeof(cmpbuf));
src_type = mkstr(big_len, H5T_STR_NULLPAD);
CHECK(src_type, FAIL, "mkstr");
/* Create a dst_type that holds half of the UTF-8 string */
small_len = length / 2;
dst_type = mkstr(small_len, H5T_STR_NULLPAD);
CHECK(dst_type, FAIL, "mkstr");
/* Fill the buffer with two copies of the UTF-8 string.
* It will look like "abcdefghabcdefgh". */
strncpy(buf, new_string, big_len);
strncpy(&buf[big_len], new_string, big_len);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
* "abcdabcdabcdefgh". Note that this is just what the bytes look
* like; UTF-8 characters may well have been truncated.
* To check that the conversion worked properly, we'll build this
* string manually. */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[small_len], new_string, small_len);
HDstrncpy(&cmpbuf[2 * small_len], new_string, big_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abcd\0\0\0\0abcd\0\0\0\0" */
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with NULLs */
HDmemset(cmpbuf, '\0', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[big_len], new_string, small_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
ret = H5Tclose(src_type);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Tclose(dst_type);
CHECK(ret, FAIL, "H5Tclose");
/* Test space padding. This is very similar to null-padding; we can
use the same values of length, small_len, and big_len. */
src_type = mkstr(big_len, H5T_STR_SPACEPAD);
CHECK(src_type, FAIL, "mkstr");
dst_type = mkstr(small_len, H5T_STR_SPACEPAD);
CHECK(src_type, FAIL, "mkstr");
/* Fill the buffer with two copies of the UTF-8 string.
* It will look like "abcdefghabcdefgh". */
HDstrcpy(buf, new_string);
HDstrcpy(&buf[big_len], new_string);
ret = H5Tconvert(src_type, dst_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* After conversion, the buffer should look like
* "abcdabcdabcdefgh". Note that this is just what the bytes look
* like; UTF-8 characters may have been truncated.
* To check that the conversion worked properly, we'll build this
* string manually. */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[small_len], new_string, small_len);
HDstrncpy(&cmpbuf[2 * small_len], new_string, big_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
/* Now convert from smaller datatype to bigger datatype. This should
* leave our buffer looking like: "abcd abcd " */
ret = H5Tconvert(dst_type, src_type, (size_t)2, buf, NULL, H5P_DEFAULT);
CHECK(ret, FAIL, "H5Tconvert");
/* First fill the buffer with spaces */
HDmemset(cmpbuf, ' ', (size_t)LONG_BUF_SIZE);
/* Copy in the characters */
HDstrncpy(cmpbuf, new_string, small_len);
HDstrncpy(&cmpbuf[big_len], new_string, small_len);
VERIFY(HDmemcmp(buf, cmpbuf, 2*big_len), 0, "HDmemcmp");
ret = H5Tclose(src_type);
CHECK(ret, FAIL, "H5Tclose");
ret = H5Tclose(dst_type);
CHECK(ret, FAIL, "H5Tclose");
}
/*-------------------------------------------------------------------------
* subroutine for test_text_dtype(): test_enums().
*-------------------------------------------------------------------------
*/
static int test_enums(void)
{
hid_t dtype;
size_t size = 16;
char name1[16];
int value1 = 7;
const char *name2 = "WHITE";
int value2;
H5T_class_t type_class;
char* dt_str;
size_t str_len;
H5T_order_t native_order = H5Tget_order(H5T_NATIVE_INT);
TESTING3(" text for enum types");
if((dtype = H5LTtext_to_dtype("H5T_ENUM { H5T_STD_I32LE; \"RED\" 5; \"GREEN\" 6; \"BLUE\" 7; \"WHITE\" 8; }", H5LT_DDL))<0)
goto out;
if((type_class = H5Tget_class(dtype))<0)
goto out;
if(type_class != H5T_ENUM)
goto out;
/* Convert the variable before using it */
if(!H5Tequal(H5T_STD_I32LE, H5T_NATIVE_INT)) {
if(H5Tconvert(H5T_NATIVE_INT, H5T_STD_I32LE, 1, &value1, NULL, H5P_DEFAULT) < 0)
goto out;
}
if(H5Tenum_nameof(dtype, &value1, name1, size)<0)
goto out;
if(strcmp(name1, "BLUE"))
goto out;
if(H5Tenum_valueof(dtype, name2, &value2)<0)
goto out;
/* Convert the variable before comparing it */
if(!H5Tequal(H5T_STD_I32LE, H5T_NATIVE_INT)) {
if(H5Tconvert(H5T_NATIVE_INT, H5T_STD_I32LE, 1, &value2, NULL, H5P_DEFAULT) < 0)
goto out;
}
if(value2 != 8)
goto out;
if(H5LTdtype_to_text(dtype, NULL, H5LT_DDL, &str_len)<0)
goto out;
dt_str = (char*)calloc(str_len, sizeof(char));
if(H5LTdtype_to_text(dtype, dt_str, H5LT_DDL, &str_len)<0)
goto out;
if(strcmp(dt_str, "H5T_ENUM {\n H5T_STD_I32LE;\n \"RED\" 5;\n \"GREEN\" 6;\n \"BLUE\" 7;\n \"WHITE\" 8;\n }")) {
printf("dt=\n%s\n", dt_str);
goto out;
}
free(dt_str);
if(H5Tclose(dtype)<0)
goto out;
PASSED();
return 0;
out:
H5_FAILED();
return -1;
}
int
main (void)
{
hid_t sourcetype, desttype, strtype, space;
/* Handles */
herr_t status;
hsize_t dims[1] = {DIM0};
reading_t *reading; /* Conversion buffer */
sensor_t *sensor, /* Conversion buffer */
bkgrd[DIM0]; /* Background buffer */
int i;
/*
* Allocate memory for conversion buffer. We will allocate space
* for it to hold DIM0 elements of the destination type, as the
* type conversion is performed in place. Of course, if the
* destination type were smaller than the source type, we would
* allocate space to hold DIM0 elements of the source type.
*/
reading = (reading_t *) malloc (DIM0 * sizeof (sensor_t));
/*
* Assign the allocated space to a pointer of the destination type,
* to allow the buffer to be accessed correctly after the
* conversion has taken place.
*/
sensor = (sensor_t *) reading;
/*
* Initialize data.
*/
bkgrd[0].serial_no = 1153;
bkgrd[0].location = "Exterior (static)";
bkgrd[0].temperature = 53.23;
bkgrd[0].pressure = 24.57;
bkgrd[1].serial_no = 1184;
bkgrd[1].location = "Intake";
bkgrd[1].temperature = 55.12;
bkgrd[1].pressure = 22.95;
bkgrd[2].serial_no = 1027;
bkgrd[2].location = "Intake manifold";
bkgrd[2].temperature = 103.55;
bkgrd[2].pressure = 31.23;
bkgrd[3].serial_no = 1313;
bkgrd[3].location = "Exhaust manifold";
bkgrd[3].temperature = 1252.89;
bkgrd[3].pressure = 84.11;
reading[0].temperature = 54.84;
reading[0].pressure = 24.76;
reading[1].temperature = 56.63;
reading[1].pressure = 23.10;
reading[2].temperature = 102.69;
reading[2].pressure = 30.97;
reading[3].temperature = 1238.27;
reading[3].pressure = 82.15;
/*
* Create variable-length string datatype.
*/
strtype = H5Tcopy (H5T_C_S1);
status = H5Tset_size (strtype, H5T_VARIABLE);
/*
* Create the compound datatype for memory.
*/
sourcetype = H5Tcreate (H5T_COMPOUND, sizeof (reading_t));
status = H5Tinsert (sourcetype, "Temperature (F)",
HOFFSET (reading_t, temperature), H5T_NATIVE_DOUBLE);
status = H5Tinsert (sourcetype, "Pressure (inHg)",
HOFFSET (reading_t, pressure), H5T_NATIVE_DOUBLE);
desttype = H5Tcreate (H5T_COMPOUND, sizeof (sensor_t));
status = H5Tinsert (desttype, "Serial number",
HOFFSET (sensor_t, serial_no), H5T_NATIVE_INT);
status = H5Tinsert (desttype, "Location", HOFFSET (sensor_t, location),
strtype);
status = H5Tinsert (desttype, "Temperature (F)",
HOFFSET (sensor_t, temperature), H5T_NATIVE_DOUBLE);
status = H5Tinsert (desttype, "Pressure (inHg)",
HOFFSET (sensor_t, pressure), H5T_NATIVE_DOUBLE);
/*
* Create dataspace. Setting maximum size to NULL sets the maximum
* size to be the current size.
*/
space = H5Screate_simple (1, dims, NULL);
/*
* Convert the buffer in reading from sourcetype to desttype.
* After this conversion we will use sensor to access the buffer,
* as the buffer now matches its type.
*/
status = H5Tconvert (sourcetype, desttype, DIM0, reading, bkgrd,
H5P_DEFAULT);
/*
* Output the data to the screen.
*/
for (i=0; i<DIM0; i++) {
printf ("sensor[%d]:\n", i);
printf ("Serial number : %d\n", sensor[i].serial_no);
printf ("Location : %s\n", sensor[i].location);
printf ("Temperature (F) : %f\n", sensor[i].temperature);
printf ("Pressure (inHg) : %f\n\n", sensor[i].pressure);
}
/*
* Close and release resources. In this case H5Tconvert preserves
* the memory locations of the variable-length strings in
* "location", so we do not need to free those strings as they were
* initialized as string constants.
*/
free (sensor);
status = H5Sclose (space);
status = H5Tclose (sourcetype);
status = H5Tclose (desttype);
status = H5Tclose (strtype);
return 0;
}
int
main(void)
{
hid_t dcpl1; /* dataset create prop. list */
hid_t dapl1; /* dataset access prop. list */
hid_t dxpl1; /* dataset xfer prop. list */
hid_t gcpl1; /* group create prop. list */
hid_t ocpypl1; /* object copy prop. list */
hid_t ocpl1; /* object create prop. list */
hid_t lcpl1; /* link create prop. list */
hid_t lapl1; /* link access prop. list */
hid_t fapl1; /* file access prop. list */
hid_t fcpl1; /* file create prop. list */
hid_t strcpl1; /* string create prop. list */
hid_t acpl1; /* attribute create prop. list */
herr_t ret = 0;
hsize_t chunk_size = 16384; /* chunk size */
int fill = 2; /* Fill value */
hsize_t max_size[1]; /* data space maximum size */
size_t nslots = 521 * 2;
size_t nbytes = 1048576 * 10;
double w0 = 0.5f;
unsigned max_compact;
unsigned min_dense;
const char* c_to_f = "x+32";
int little_endian;
int word_length;
H5AC_cache_config_t my_cache_config = {
H5AC__CURR_CACHE_CONFIG_VERSION,
1 /*TRUE*/,
0 /*FALSE*/,
0 /*FALSE*/,
"temp",
1 /*TRUE*/,
0 /*FALSE*/,
( 2 * 2048 * 1024),
0.3f,
(64 * 1024 * 1024),
(4 * 1024 * 1024),
60000,
H5C_incr__threshold,
0.8f,
3.0f,
1 /*TRUE*/,
(8 * 1024 * 1024),
H5C_flash_incr__add_space,
2.0f,
0.25f,
H5C_decr__age_out_with_threshold,
0.997f,
0.8f,
1 /*TRUE*/,
(3 * 1024 * 1024),
3,
0 /*FALSE*/,
0.2f,
(256 * 2048),
H5AC_METADATA_WRITE_STRATEGY__PROCESS_0_ONLY};
H5AC_cache_image_config_t my_cache_image_config = {
H5AC__CURR_CACHE_IMAGE_CONFIG_VERSION,
TRUE,
FALSE,
-1};
/* check endianess */
{
short int word = 0x0001;
char *byte = (char *) &word;
if(byte[0] == 1)
/* little endian */
little_endian = 1;
else
/* big endian */
little_endian = 0;
}
/* check word length */
{
word_length = 8 * sizeof(void *);
}
/* Explicitly initialize the library, since we are including the private header file */
H5open();
/******* ENCODE/DECODE DCPLS *****/
if((dcpl1 = H5Pcreate(H5P_DATASET_CREATE)) < 0)
assert(dcpl1 > 0);
if((ret = encode_plist(dcpl1, little_endian, word_length, "testfiles/plist_files/def_dcpl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_chunk(dcpl1, 1, &chunk_size)) < 0)
assert(ret > 0);
if((ret = H5Pset_alloc_time(dcpl1, H5D_ALLOC_TIME_LATE)) < 0)
assert(ret > 0);
ret = H5Tconvert(H5T_NATIVE_INT, H5T_STD_I32BE, (size_t)1, &fill, NULL, H5P_DEFAULT);
assert(ret >= 0);
if((ret = H5Pset_fill_value(dcpl1, H5T_STD_I32BE, &fill)) < 0)
assert(ret > 0);
max_size[0] = 100;
if((ret = H5Pset_external(dcpl1, "ext1.data", (off_t)0,
(hsize_t)(max_size[0] * sizeof(int)/4))) < 0)
assert(ret > 0);
if((ret = H5Pset_external(dcpl1, "ext2.data", (off_t)0,
(hsize_t)(max_size[0] * sizeof(int)/4))) < 0)
assert(ret > 0);
if((ret = H5Pset_external(dcpl1, "ext3.data", (off_t)0,
(hsize_t)(max_size[0] * sizeof(int)/4))) < 0)
assert(ret > 0);
if((ret = H5Pset_external(dcpl1, "ext4.data", (off_t)0,
(hsize_t)(max_size[0] * sizeof(int)/4))) < 0)
assert(ret > 0);
if((ret = encode_plist(dcpl1, little_endian, word_length, "testfiles/plist_files/dcpl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(dcpl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE DAPLS *****/
if((dapl1 = H5Pcreate(H5P_DATASET_ACCESS)) < 0)
assert(dapl1 > 0);
if((ret = encode_plist(dapl1, little_endian, word_length, "testfiles/plist_files/def_dapl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_chunk_cache(dapl1, nslots, nbytes, w0)) < 0)
assert(ret > 0);
if((ret = encode_plist(dapl1, little_endian, word_length, "testfiles/plist_files/dapl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(dapl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE DXPLS *****/
if((dxpl1 = H5Pcreate(H5P_DATASET_XFER)) < 0)
assert(dxpl1 > 0);
if((ret = encode_plist(dxpl1, little_endian, word_length, "testfiles/plist_files/def_dxpl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_btree_ratios(dxpl1, 0.2f, 0.6f, 0.2f)) < 0)
assert(ret > 0);
if((ret = H5Pset_hyper_vector_size(dxpl1, 5)) < 0)
assert(ret > 0);
#ifdef H5_HAVE_PARALLEL
if((ret = H5Pset_dxpl_mpio(dxpl1, H5FD_MPIO_COLLECTIVE)) < 0)
assert(ret > 0);
if((ret = H5Pset_dxpl_mpio_collective_opt(dxpl1, H5FD_MPIO_INDIVIDUAL_IO)) < 0)
assert(ret > 0);
if((ret = H5Pset_dxpl_mpio_chunk_opt(dxpl1, H5FD_MPIO_CHUNK_MULTI_IO)) < 0)
assert(ret > 0);
if((ret = H5Pset_dxpl_mpio_chunk_opt_ratio(dxpl1, 30)) < 0)
assert(ret > 0);
if((ret = H5Pset_dxpl_mpio_chunk_opt_num(dxpl1, 40)) < 0)
assert(ret > 0);
#endif/* H5_HAVE_PARALLEL */
if((ret = H5Pset_edc_check(dxpl1, H5Z_DISABLE_EDC)) < 0)
assert(ret > 0);
if((ret = H5Pset_data_transform(dxpl1, c_to_f)) < 0)
assert(ret > 0);
if((ret = encode_plist(dxpl1, little_endian, word_length, "testfiles/plist_files/dxpl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(dxpl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE GCPLS *****/
if((gcpl1 = H5Pcreate(H5P_GROUP_CREATE)) < 0)
assert(gcpl1 > 0);
if((ret = encode_plist(gcpl1, little_endian, word_length, "testfiles/plist_files/def_gcpl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_local_heap_size_hint(gcpl1, 256)) < 0)
assert(ret > 0);
if((ret = H5Pset_link_phase_change(gcpl1, 2, 2)) < 0)
assert(ret > 0);
/* Query the group creation properties */
if((ret = H5Pget_link_phase_change(gcpl1, &max_compact, &min_dense)) < 0)
assert(ret > 0);
if((ret = H5Pset_est_link_info(gcpl1, 3, 9)) < 0)
assert(ret > 0);
if((ret = H5Pset_link_creation_order(gcpl1, (H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED))) < 0)
assert(ret > 0);
if((ret = encode_plist(gcpl1, little_endian, word_length, "testfiles/plist_files/gcpl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(gcpl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE LCPLS *****/
if((lcpl1 = H5Pcreate(H5P_LINK_CREATE)) < 0)
assert(lcpl1 > 0);
if((ret = encode_plist(lcpl1, little_endian, word_length, "testfiles/plist_files/def_lcpl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_create_intermediate_group(lcpl1, 1 /*TRUE*/)) < 0)
assert(ret > 0);
if((ret = encode_plist(lcpl1, little_endian, word_length, "testfiles/plist_files/lcpl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(lcpl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE OCPYLS *****/
if((ocpypl1 = H5Pcreate(H5P_OBJECT_COPY)) < 0)
assert(ocpypl1 > 0);
if((ret = encode_plist(ocpypl1, little_endian, word_length, "testfiles/plist_files/def_ocpypl_")) < 0)
assert(ret > 0);
ret = H5Pset_copy_object(ocpypl1, H5O_COPY_EXPAND_EXT_LINK_FLAG);
assert(ret >= 0);
ret = H5Padd_merge_committed_dtype_path(ocpypl1, "foo");
assert(ret >= 0);
ret = H5Padd_merge_committed_dtype_path(ocpypl1, "bar");
assert(ret >= 0);
if((ret = encode_plist(ocpypl1, little_endian, word_length, "testfiles/plist_files/ocpypl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(ocpypl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE OCPLS *****/
if((ocpl1 = H5Pcreate(H5P_OBJECT_CREATE)) < 0)
assert(ocpl1 > 0);
if((ret = encode_plist(ocpl1, little_endian, word_length, "testfiles/plist_files/def_ocpl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_attr_creation_order(ocpl1, (H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED))) < 0)
assert(ret > 0);
if((ret = H5Pset_attr_phase_change (ocpl1, 110, 105)) < 0)
assert(ret > 0);
if((ret = H5Pset_filter (ocpl1, H5Z_FILTER_FLETCHER32, 0, (size_t)0, NULL)) < 0)
assert(ret > 0);
if((ret = encode_plist(ocpl1, little_endian, word_length, "testfiles/plist_files/ocpl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(ocpl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE LAPLS *****/
if((lapl1 = H5Pcreate(H5P_LINK_ACCESS)) < 0)
assert(lapl1 > 0);
if((ret = encode_plist(lapl1, little_endian, word_length, "testfiles/plist_files/def_lapl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_nlinks(lapl1, (size_t)134)) < 0)
assert(ret > 0);
if((ret = H5Pset_elink_acc_flags(lapl1, H5F_ACC_RDONLY)) < 0)
assert(ret > 0);
if((ret = H5Pset_elink_prefix(lapl1, "/tmpasodiasod")) < 0)
assert(ret > 0);
/* Create FAPL for the elink FAPL */
if((fapl1 = H5Pcreate(H5P_FILE_ACCESS)) < 0)
assert(fapl1 > 0);
if((ret = H5Pset_alignment(fapl1, 2, 1024)) < 0)
assert(ret > 0);
if((ret = H5Pset_elink_fapl(lapl1, fapl1)) < 0)
assert(ret > 0);
/* Close the elink's FAPL */
if((ret = H5Pclose(fapl1)) < 0)
assert(ret > 0);
if((ret = encode_plist(lapl1, little_endian, word_length, "testfiles/plist_files/lapl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(lapl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE FAPLS *****/
if((fapl1 = H5Pcreate(H5P_FILE_ACCESS)) < 0)
assert(fapl1 > 0);
if((ret = encode_plist(fapl1, little_endian, word_length, "testfiles/plist_files/def_fapl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_family_offset(fapl1, 1024)) < 0)
assert(ret > 0);
if((ret = H5Pset_meta_block_size(fapl1, 2098452)) < 0)
assert(ret > 0);
if((ret = H5Pset_sieve_buf_size(fapl1, 1048576)) < 0)
assert(ret > 0);
if((ret = H5Pset_alignment(fapl1, 2, 1024)) < 0)
assert(ret > 0);
if((ret = H5Pset_cache(fapl1, 1024, 128, 10485760, 0.3f)) < 0)
assert(ret > 0);
if((ret = H5Pset_elink_file_cache_size(fapl1, 10485760)) < 0)
assert(ret > 0);
if((ret = H5Pset_gc_references(fapl1, 1)) < 0)
assert(ret > 0);
if((ret = H5Pset_small_data_block_size(fapl1, 2048)) < 0)
assert(ret > 0);
if((ret = H5Pset_libver_bounds(fapl1, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST)) < 0)
assert(ret > 0);
if((ret = H5Pset_fclose_degree(fapl1, H5F_CLOSE_WEAK)) < 0)
assert(ret > 0);
if((ret = H5Pset_multi_type(fapl1, H5FD_MEM_GHEAP)) < 0)
assert(ret > 0);
if((ret = H5Pset_mdc_config(fapl1, &my_cache_config)) < 0)
assert(ret > 0);
if((ret = H5Pset_mdc_image_config(fapl1, &my_cache_image_config)) < 0)
assert(ret > 0);
if((ret = H5Pset_core_write_tracking(fapl1, TRUE, (size_t)(1024 * 1024))) < 0)
assert(ret > 0);
if((ret = encode_plist(fapl1, little_endian, word_length, "testfiles/plist_files/fapl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(fapl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE FCPLS *****/
if((fcpl1 = H5Pcreate(H5P_FILE_CREATE)) < 0)
assert(fcpl1 > 0);
if((ret = encode_plist(fcpl1, little_endian, word_length, "testfiles/plist_files/def_fcpl_")) < 0)
assert(ret > 0);
if((ret = H5Pset_userblock(fcpl1, 1024) < 0))
assert(ret > 0);
if((ret = H5Pset_istore_k(fcpl1, 3) < 0))
assert(ret > 0);
if((ret = H5Pset_sym_k(fcpl1, 4, 5) < 0))
assert(ret > 0);
if((ret = H5Pset_shared_mesg_nindexes(fcpl1, 8) < 0))
assert(ret > 0);
if((ret = H5Pset_shared_mesg_index(fcpl1, 1, H5O_SHMESG_SDSPACE_FLAG, 32) < 0))
assert(ret > 0);
if((ret = H5Pset_shared_mesg_phase_change(fcpl1, 60, 20) < 0))
assert(ret > 0);
if((ret = H5Pset_sizes(fcpl1, 8, 4) < 0))
assert(ret > 0);
if((ret = H5Pset_file_space_strategy(fcpl1, H5F_FSPACE_STRATEGY_PAGE, TRUE, (hsize_t)1)) < 0)
assert(ret > 0);
if((ret = H5Pset_file_space_page_size(fcpl1, (hsize_t)4096)) < 0)
assert(ret > 0);
if((ret = encode_plist(fcpl1, little_endian, word_length, "testfiles/plist_files/fcpl_")) < 0)
assert(ret > 0);
/* release resource */
if((ret = H5Pclose(fcpl1)) < 0)
assert(ret > 0);
/******* ENCODE/DECODE STRCPLS *****/
strcpl1 = H5Pcreate(H5P_STRING_CREATE);
assert(strcpl1 > 0);
ret = encode_plist(strcpl1, little_endian, word_length, "testfiles/plist_files/def_strcpl_");
assert(ret > 0);
ret = H5Pset_char_encoding(strcpl1, H5T_CSET_UTF8);
assert(ret >= 0);
ret = encode_plist(strcpl1, little_endian, word_length, "testfiles/plist_files/strcpl_");
assert(ret > 0);
/* release resource */
ret = H5Pclose(strcpl1);
assert(ret >= 0);
/******* ENCODE/DECODE ACPLS *****/
acpl1 = H5Pcreate(H5P_ATTRIBUTE_CREATE);
assert(acpl1 > 0);
ret = encode_plist(acpl1, little_endian, word_length, "testfiles/plist_files/def_acpl_");
assert(ret > 0);
ret = H5Pset_char_encoding(acpl1, H5T_CSET_UTF8);
assert(ret >= 0);
ret = encode_plist(acpl1, little_endian, word_length, "testfiles/plist_files/acpl_");
assert(ret > 0);
/* release resource */
ret = H5Pclose(acpl1);
assert(ret >= 0);
return 0;
}