/*-------------------------------------------------------------------------
* test_opaque
*
* Tests that the packet table works with an opaque datatype.
*
*-------------------------------------------------------------------------
*/
static int test_opaque(hid_t fid)
{
herr_t err;
hid_t table;
hid_t part_t;
size_t c;
particle_t readBuf[NRECORDS];
TESTING("opaque data");
/* Create an opaque datatype for the particle struct */
if ((part_t = H5Tcreate (H5T_OPAQUE, sizeof(particle_t) )) < 0 )
return -1;
HDassert(part_t != -1);
/* Tag the opaque datatype */
if ( H5Tset_tag(part_t, "Opaque Particle" ) < 0)
return -1;
/* Create a new table */
table = H5PTcreate_fl(fid, "Packet Test Dataset3", part_t, (hsize_t)100, -1);
H5Tclose(part_t);
if( H5PTis_valid(table) < 0)
goto out;
/* Append several particles, starting at particle 1 */
err = H5PTappend(table, (size_t)(NRECORDS - 1), &(testPart[1]));
if( err < 0)
goto out;
/* Read the particles back */
err = H5PTread_packets(table, (hsize_t)0, 7, &(readBuf[0]));
if( err < 0)
goto out;
/* Ensure that particles were read correctly */
for(c=0; c<NRECORDS - 1; c++)
{
if( cmp_par(c+1, c, testPart, readBuf) != 0)
goto out;
}
/* Close the table */
err = H5PTclose(table);
if( err < 0)
goto out;
PASSED();
return 0;
out:
H5_FAILED();
if( H5PTis_valid(table) < 0)
H5PTclose(table);
return -1;
}
/*
* test_opaque
* Test comments on opaque datatypes
*/
void test_opaque(hid_t UNUSED fid, const char * string)
{
hid_t type_id;
char * read_buf;
herr_t ret;
/* Create an opaque type and give it a UTF-8 tag */
type_id = H5Tcreate(H5T_OPAQUE, (size_t)4);
CHECK(type_id, FAIL, "H5Tcreate");
ret = H5Tset_tag(type_id, string);
CHECK(ret, FAIL, "H5Tset_tag");
/* Read the tag back. */
read_buf = H5Tget_tag(type_id);
ret = strcmp(read_buf, string);
VERIFY(ret, 0, "H5Tget_tag");
H5free_memory(read_buf);
ret = H5Tclose(type_id);
CHECK(ret, FAIL, "H5Tclose");
}
int
main (void)
{
hid_t file, space, dtype, dset; /* Handles */
herr_t status;
hsize_t dims[1] = {DIM0};
size_t len;
char wdata[DIM0*LEN], /* Write buffer */
*rdata, /* Read buffer */
str[LEN] = "OPAQUE",
*tag;
int ndims,
i, j;
/*
* Initialize data.
*/
for (i=0; i<DIM0; i++) {
for (j=0; j<LEN-1; j++)
wdata[j + i * LEN] = str[j];
wdata[LEN - 1 + i * LEN] = (char) i + '0';
}
/*
* Create a new file using the default properties.
*/
file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create opaque datatype and set the tag to something appropriate.
* For this example we will write and view the data as a character
* array.
*/
dtype = H5Tcreate (H5T_OPAQUE, LEN);
status = H5Tset_tag (dtype, "Character array");
/*
* Create dataspace. Setting maximum size to NULL sets the maximum
* size to be the current size.
*/
space = H5Screate_simple (1, dims, NULL);
/*
* Create the dataset and write the opaque data to it.
*/
dset = H5Dcreate (file, DATASET, dtype, space, H5P_DEFAULT, H5P_DEFAULT,
H5P_DEFAULT);
status = H5Dwrite (dset, dtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata);
/*
* Close and release resources.
*/
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (dtype);
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().
*/
/*
* Open file and dataset.
*/
file = H5Fopen (FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
dset = H5Dopen (file, DATASET, H5P_DEFAULT);
/*
* Get datatype and properties for the datatype. Note that H5Tget_tag
* allocates space for the string in tag, so we must remember to free() it
* later.
*/
dtype = H5Dget_type (dset);
len = H5Tget_size (dtype);
tag = H5Tget_tag (dtype);
/*
* Get dataspace and allocate memory for read buffer.
*/
space = H5Dget_space (dset);
ndims = H5Sget_simple_extent_dims (space, dims, NULL);
rdata = (char *) malloc (dims[0] * len);
/*
* Read the data.
*/
status = H5Dread (dset, dtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);
/*
* Output the data to the screen.
*/
printf ("Datatype tag for %s is: \"%s\"\n", DATASET, tag);
for (i=0; i<dims[0]; i++) {
printf ("%s[%u]: ", DATASET, i);
for (j=0; j<len; j++)
printf ("%c", rdata[j + i * len]);
printf ("\n");
}
/*
* Close and release resources.
*/
free (rdata);
free (tag);
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Tclose (dtype);
status = H5Fclose (file);
return 0;
}
int writetoh5(std::string tmpfileo, struct param par) {
hid_t h5file_id;
hid_t dtype_id;
hid_t dspace_id;
hid_t dset_id;
char *buffer;
int err;
std::string cpath, cname;
std::string patho = (std::string) par.patho;
std::string conto = (std::string) par.conto;
std::string grupo = (std::string) par.grupo;
std::string fileo = (std::string) par.fileo;
cpath = patho + "/" + conto;
cname = grupo + "/" + fileo;
/* open image */
FILE *fi = fopen(tmpfileo.c_str(),"r"); CHKRTN(!fi, FILEERR);
/* get file length */
fseek(fi, 0, SEEK_END);
hsize_t filen = ftell(fi);
fseek(fi, 0, SEEK_SET);
/* allocate memory */
buffer = (char *)malloc(filen+1); CHKRTN(!buffer, MEMERR);
/* read image */
fread(buffer, filen, 1, fi);
/* close file */
fclose(fi);
/* open container. it has to be created somewhere else. */
h5file_id = H5Fopen(cpath.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
CHKRTN(h5file_id < 0, FILEERR);
/* Create the datatype */
dtype_id = H5Tcreate(H5T_OPAQUE, 1);
/* Set the datatype tag */
err = H5Tset_tag(dtype_id, "Opaque Test Tag"); CHKERR(err);
/* Create the dataspace */
dspace_id = H5Screate_simple(1, &filen, NULL);
/* Create the dataset */
dset_id = H5Dcreate(h5file_id, cname.c_str(), dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
/* Write the data out to the dataset */
err = H5Dwrite(dset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buffer); CHKERR(err);
/* Close resource handles */
err = H5Dclose(dset_id); CHKERR(err);
err = H5Sclose(dspace_id); CHKERR(err);
err = H5Tclose(dtype_id); CHKERR(err);
err = H5Fclose(h5file_id); CHKERR(err);
free(buffer);
return EXIT_SUCCESS;
}
