/************************************************************
Operator function. Prints the name and type of the object
being examined.
************************************************************/
static herr_t op_func_v1(hid_t loc_id, const char *name, const H5L_info_t *info, void *operator_data)
{
H5O_info_t oinfo;
herr_t status = 0;
int *pDataSetId = (int*)operator_data;
hid_t obj = H5Oopen(loc_id, name, H5P_DEFAULT);
if (obj < 0)
{
return -1;
}
/*
* Get type of the object and return only datasetId
* through operator_data.
*/
status = H5Oget_info(obj, &oinfo);
if (status < 0)
{
H5Oclose(obj);
return -1;
}
if (oinfo.type == H5O_TYPE_DATASET)
{
*pDataSetId = obj;
}
else
{
H5Oclose(obj);
}
return 0;
}
char* test_utf_8() {
hid_t file, node, unode, dset;
size_t len;
char res, *path, *attr, **dset_val;
file = H5Fopen(FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
mu_assert("H5Fopen() open file...", file >= 0);
mu_assert("Valid node path...", AH5_path_valid(file, NODE_PATH));
node = H5Oopen(file, NODE_PATH, H5P_DEFAULT);
mu_assert("H5Oopen() open node...", node >= 0);
mu_assert("Valid unode path...", AH5_path_valid(node, UNODE_PATH));
unode = H5Oopen(node, UNODE_PATH, H5P_DEFAULT);
mu_assert("H5Oopen() open unode...", unode >= 0);
H5Oclose(unode);
path = (char*) malloc(sizeof(char) * (1 + strlen(NODE_PATH) + 1 + strlen(UNODE_PATH) + 1));
path[0] = '/';
path[1] = '\0';
strcat(path, NODE_PATH);
strcat(path, "/");
strcat(path, UNODE_PATH);
mu_assert("Valid unode absolute path...", AH5_path_valid(file, path));
unode = H5Oopen(file, path, H5P_DEFAULT);
mu_assert("H5Oopen() open unode...", unode >= 0);
free(path);
len = AH5_read_str_attr_len(unode, ".", "attribut du sous-nœud accentué");
mu_assert("AH5_read_str_attr_len() read utf-8 attr len...", len > 0);
attr = (char*) malloc(sizeof(char) * (len + 1));
res = AH5_read_str_attr(unode, ".", "attribut du sous-nœud accentué", &attr);
mu_assert("AH5_read_str_attr() status...", res == AH5_TRUE);
mu_assert("AH5_read_str_attr() str length...", strlen(attr) == strlen("é è à œ"));
mu_assert("AH5_read_str_attr() str value...", strcmp(attr, "é è à œ") == 0);
free(attr);
mu_assert("Valid dset path...", AH5_path_valid(unode, DSET_PATH));
dset = H5Oopen(unode, DSET_PATH, H5P_DEFAULT);
mu_assert("H5Oopen() open dset...", dset >= 0);
len = 11;
dset_val = (char**) malloc(sizeof(char*));
dset_val[0] = (char*) malloc(sizeof(char) * (len + 1));
res = AH5_read_str_dataset(dset, ".", 1, len, &dset_val);
mu_assert("AH5_read_str_dataset() status...", res == AH5_TRUE);
mu_assert("AH5_read_str_dataset() str length...", strlen(dset_val[0]) == strlen("é è à œ"));
mu_assert("AH5_read_str_dataset() str value...", strcmp(dset_val[0], "é è à œ") == 0);
free(dset_val[0]);
free(dset_val);
H5Oclose(dset);
H5Oclose(unode);
H5Oclose(node);
H5Fclose(file);
return MU_FINISHED_WITHOUT_ERRORS;
}
/*-------------------------------------------------------------*/
static hid_t findDependentField(pNXVcontext self,
hid_t inFieldID,char *dpData)
{
char *pPtr;
hid_t fieldID, groupID;
char fname[512], newPath[1024], groupName[1024];
/*
get at enclosing group
*/
memset(groupName,0,sizeof(groupName));
H5Iget_name(inFieldID,groupName,sizeof(groupName));
pPtr = strrchr(groupName,'/');
*pPtr = '\0';
pPtr = NULL;
pPtr = strchr(dpData,'/');
if(pPtr != NULL){
if(pPtr == dpData){
/* absolute path */
if(H5LTpath_valid(self->fileID,dpData,1)){
fieldID = H5Oopen(self->fileID,dpData,H5P_DEFAULT);
return fieldID;
} else {
return -1;
}
} else {
/* relative path further along the path */
snprintf(newPath,sizeof(newPath), "%s/%s", groupName, dpData);
if(H5LTpath_valid(self->fileID,newPath,1)){
fieldID = H5Oopen(self->fileID,newPath,H5P_DEFAULT);
return fieldID;
} else {
return -1;
}
}
} else {
/* path within the group */
groupID = H5Oopen(self->fileID, groupName,H5P_DEFAULT);
if(H5LTfind_dataset(groupID,dpData)){
fieldID = H5Dopen(groupID,dpData,H5P_DEFAULT);
H5Oclose(groupID);
return fieldID;
} else {
H5Oclose(groupID);
return -1;
}
}
return -1;
}
H5Object & H5ReferenceData::getData(const unsigned int size, const unsigned int * index) const
{
char * cdata = static_cast<char *>(data) + offset;
void ** ref = 0;
unsigned int pos = 0;
unsigned int cumprod = 1;
H5O_info_t info;
H5Object * hobj;
hid_t obj;
hid_t file;
ssize_t ssize;
char * name = 0;
std::string _name;
for (unsigned int i = 0; i < size; i++)
{
pos += cumprod * index[i];
}
if (pos >= totalSize)
{
throw H5Exception(__LINE__, __FILE__, _("Invalid index."));
}
cdata += pos * (stride ? stride : dataSize);
file = getFile().getH5Id();
ref = &(((void **)cdata)[0]);
obj = H5Rdereference(file, datasetReference ? H5R_DATASET_REGION : H5R_OBJECT, ref);
if (obj < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot open object at the given position."));
}
ssize = H5Rget_name(file, datasetReference ? H5R_DATASET_REGION : H5R_OBJECT, ref, 0, 0);
name = new char[ssize + 1];
H5Rget_name(file, datasetReference ? H5R_DATASET_REGION : H5R_OBJECT, ref, name, ssize + 1);
_name = std::string(name);
delete[] name;
H5Oget_info(obj, &info);
switch (info.type)
{
case H5O_TYPE_GROUP:
hobj = new H5Group(getParent(), obj, _name);
break;
case H5O_TYPE_DATASET:
hobj = new H5Dataset(getParent(), obj, _name);
break;
case H5O_TYPE_NAMED_DATATYPE:
hobj = new H5Type(getParent(), obj, _name);
break;
case H5O_TYPE_UNKNOWN:
default:
H5Oclose(obj);
throw H5Exception(__LINE__, __FILE__, _("Unknown HDF5 object"));
}
return *hobj;
}
/* This is a callback function for H5Literate().
The parameters of this callback function have the following values or
meanings:
g_id Group that serves as root of the iteration; same value as the
H5Lvisit group_id parameter
name Name of link, relative to g_id, being examined at current step of
the iteration
info H5L_info_t struct containing information regarding that link
op_data User-defined pointer to data required by the application in
processing the link; a pass-through of the op_data pointer provided
with the H5Lvisit function call
*/
herr_t
op_func (hid_t g_id, const char *name, const H5L_info_t *info,
void *op_data)
{
hid_t id;
H5I_type_t obj_type;
strcpy((char *)op_data, name);
if ((id = H5Oopen_by_addr(g_id, info->u.address)) < 0) ERR;
/* Using H5Ovisit is really slow. Use H5Iget_type for a fast
* answer. */
/* if (H5Ovisit(id, H5_INDEX_CRT_ORDER, H5_ITER_INC, obj_iter, */
/* (void *)&obj_class) != 1) ERR; */
if ((obj_type = H5Iget_type(id)) < 0) ERR;
if (H5Oclose(id) < 0) ERR;
/* Turn this on to learn what type of object you've opened. */
/* switch (obj_type) */
/* { */
/* case H5I_GROUP: */
/* printf("group %s\n", name); */
/* break; */
/* case H5I_DATATYPE: */
/* printf("type %s\n", name); */
/* break; */
/* case H5I_DATASET: */
/* printf("data %s\n", name); */
/* break; */
/* default: */
/* printf("unknown class\n"); */
/* } */
return 1;
}
// Write complex attribute <attr_name> given by address <path>
char AH5_write_cpx_attr(hid_t loc_id, const char* path, char* attr_name, const AH5_complex_t wdata)
{
char success = AH5_FALSE;
hid_t attr_id = 0, cpx_filetype, cpx_memtype, object_id, space;
hsize_t dims[1] = {1};
cpx_filetype = AH5_H5Tcreate_cpx_filetype();
cpx_memtype = AH5_H5Tcreate_cpx_memtype();
space = H5Screate_simple (1, dims, NULL);
if (AH5_path_valid(loc_id, path))
{
if ((object_id = H5Oopen(loc_id, path, H5P_DEFAULT)) >= 0)
{
if ((attr_id = H5Acreate(object_id, attr_name, cpx_filetype, space, H5P_DEFAULT, H5P_DEFAULT)) >= 0)
{
if (H5Awrite(attr_id, cpx_memtype, &wdata) >= 0)
{
success = AH5_TRUE;
}
H5Aclose(attr_id);
}
H5Oclose(object_id);
}
}
H5Sclose(space);
H5Tclose(cpx_memtype);
H5Tclose(cpx_filetype);
return success;
}
static herr_t
visit_link(hid_t g_id, const char *name, const H5L_info_t *info,
void *op_data)
{
/* A positive return value causes the visit iterator to immediately
* return that positive value, indicating short-circuit
* success. The iterator can be restarted at the next group
* member. */
int ret = 1;
hid_t id;
strncpy(((struct nc_hdf5_link_info *)op_data)->name, name, NC_MAX_NAME);
/* Open this critter. */
if ((id = H5Oopen_by_addr(g_id, info->u.address)) < 0)
return NC_EHDFERR;
/* Is this critter a group, type, data, attribute, or what? */
if ((((struct nc_hdf5_link_info *)op_data)->obj_type = H5Iget_type(id)) < 0)
ret = NC_EHDFERR;
/* Close the critter to release resouces. */
if (H5Oclose(id) < 0)
return NC_EHDFERR;
return ret;
}
//-*****************************************************************************
void CloseObject( H5Node& iNode )
{
if ( iNode.isValidObject() )
{
H5Oclose( iNode.getObject() );
iNode.setObject( -1 );
}
}
herr_t H5Group::getLsInfo(hid_t g_id, const char * name, const H5L_info_t * info, void * op_data)
{
H5O_info_t oinfo;
herr_t err;
hid_t obj;
OpDataGetLs & opdata = *(OpDataGetLs *)op_data;
switch (info->type)
{
case H5L_TYPE_SOFT:
opdata.name->push_back(name);
opdata.type->push_back("soft");
break;
case H5L_TYPE_EXTERNAL:
opdata.name->push_back(name);
opdata.type->push_back("external");
break;
case H5L_TYPE_HARD:
obj = H5Oopen_by_addr(g_id, info->u.address);
if (obj < 0)
{
return (herr_t) - 1;
}
err = H5Oget_info(obj, &oinfo);
H5Oclose(obj);
if (err < 0)
{
return (herr_t) - 1;
}
switch (oinfo.type)
{
case H5O_TYPE_GROUP:
opdata.name->push_back(name);
opdata.type->push_back("group");
break;
case H5O_TYPE_DATASET:
opdata.name->push_back(name);
opdata.type->push_back("dataset");
break;
case H5O_TYPE_NAMED_DATATYPE:
opdata.name->push_back(name);
opdata.type->push_back("type");
break;
default:
return (herr_t) - 1;
}
break;
default:
return (herr_t) - 1;
}
return (herr_t)0;
}
/*
* Class: hdf_hdf5lib_H5
* Method: _H5Oclose
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_hdf_hdf5lib_H5__1H5Oclose
(JNIEnv *env, jclass clss, jlong object_id)
{
herr_t retVal = H5Oclose((hid_t)object_id);
if (retVal < 0)
h5libraryError(env);
return (jint)retVal;
} /* end Java_hdf_hdf5lib_H5__1H5Oclose */
/****if* H5Of/h5oclose_c
* NAME
* h5oclose_c
* PURPOSE
* Call H5Oclose
* INPUTS
* object_id - Object identifier
* RETURNS
* 0 on success, -1 on failure
* AUTHOR
* M. Scot Breitenfeld
* December 17, 2008
* SOURCE
*/
int_f
nh5oclose_c ( hid_t_f *object_id )
/******/
{
int_f ret_value=0; /* Return value */
if (H5Oclose((hid_t)*object_id) < 0)
HGOTO_DONE(FAIL);
done:
return ret_value;
}
herr_t H5Group::printLsInfo(hid_t g_id, const char * name, const H5L_info_t * info, void * op_data)
{
H5O_info_t oinfo;
herr_t err;
H5Object * hobj = 0;
hid_t obj = 0;
OpDataPrintLs & opdata = *(OpDataPrintLs *)op_data;
switch (info->type)
{
case H5L_TYPE_SOFT:
hobj = new H5SoftLink(*opdata.parent, name);
break;
case H5L_TYPE_EXTERNAL:
hobj = new H5ExternalLink(*opdata.parent, name);
break;
case H5L_TYPE_HARD:
obj = H5Oopen(g_id, name, H5P_DEFAULT);
err = H5Oget_info(obj, &oinfo);
H5Oclose(obj);
if (err < 0)
{
return (herr_t) - 1;
}
switch (oinfo.type)
{
case H5O_TYPE_GROUP:
hobj = new H5Group(*opdata.parent, name);
break;
case H5O_TYPE_DATASET:
hobj = new H5Dataset(*opdata.parent, name);
break;
case H5O_TYPE_NAMED_DATATYPE:
hobj = new H5Type(*opdata.parent, name);
break;
default:
return (herr_t) - 1;
}
break;
default:
return (herr_t) - 1;
}
hobj->printLsInfo(*opdata.os);
delete hobj;
return (herr_t)0;
}
/*
* Class: hdf_hdf5lib_H5
* Method: _H5Oclose
* Signature: (J)I
*/
JNIEXPORT jint JNICALL
Java_hdf_hdf5lib_H5__1H5Oclose
(JNIEnv *env, jclass clss, jlong object_id)
{
herr_t retVal = FAIL;
UNUSED(clss);
if ((retVal = H5Oclose((hid_t)object_id)) < 0)
H5_LIBRARY_ERROR(ENVONLY);
done:
return (jint)retVal;
} /* end Java_hdf_hdf5lib_H5__1H5Oclose */
H5Object & H5File::getRoot()
{
hid_t obj = H5Oopen(getH5Id(), path.c_str(), H5P_DEFAULT);
if (obj < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Invalid path: %s"), path.c_str());
}
try
{
return H5Object::getObject(*this, obj);
}
catch (const H5Exception & /*e*/)
{
H5Oclose(obj);
throw;
}
}
void DCGroup::getEntriesInternal(H5Handle base, const std::string baseGroup,
std::string baseName, VisitObjCBType *param)
throw (DCException)
{
H5G_info_t group_info;
H5Gget_info(base, &group_info);
for (size_t i = 0; i < group_info.nlinks; ++i)
{
std::string currentBaseName = baseName;
std::string currentEntryName = "";
H5O_info_t obj_info;
H5Oget_info_by_idx(base, ".", H5_INDEX_NAME, H5_ITER_INC, i, &obj_info, H5P_DEFAULT);
if (param->entries)
{
ssize_t len_name = H5Lget_name_by_idx(base, ".", H5_INDEX_NAME,
H5_ITER_INC, i, NULL, 0, H5P_LINK_ACCESS_DEFAULT);
char *link_name_c = new char[len_name + 1];
H5Lget_name_by_idx(base, ".", H5_INDEX_NAME,
H5_ITER_INC, i, link_name_c, len_name + 1, H5P_LINK_ACCESS_DEFAULT);
currentEntryName = std::string(link_name_c) + std::string("/");
currentBaseName += currentEntryName;
delete[] link_name_c;
}
if (obj_info.type == H5O_TYPE_GROUP)
{
hid_t group_id = H5Oopen_by_idx(base, ".", H5_INDEX_NAME, H5_ITER_INC, i, H5P_DEFAULT);
getEntriesInternal(group_id, baseGroup, currentBaseName, param);
H5Oclose(group_id);
}
if (obj_info.type == H5O_TYPE_DATASET)
{
if (param->entries)
param->entries[param->count].name = currentEntryName;
param->count++;
}
}
}
/*-------------------------------------------------------------------------
* Function: flush_verification
*
* Purpose: This function tries to open target object in the test file.
* It compares the success of the open function to the expected
* value, and succeeds if they are equal and fails if they differ.
*
* Note that full path to the object must be provided as the
* obj_pathname argument.
*
* Return: 0 on Success, 1 on Failure
*
* Programmer: Mike McGreevy
* July 16, 2010
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t flush_verification(const char * obj_pathname, const char * expected)
{
/* Variables */
hid_t oid,fid,status = 0;
H5O_info_t oinfo;
/* Try to open the testfile and then obj_pathname within the file */
H5E_BEGIN_TRY {
fid = H5Fopen(FILENAME, H5F_ACC_SWMR_READ, H5P_DEFAULT);
oid = H5Oopen(fid, obj_pathname, H5P_DEFAULT);
status = H5Oget_info(oid, &oinfo);
} H5E_END_TRY;
/* Compare to expected result */
if (strcmp(expected, FLUSHED) == 0) {
if ((oid < 0) || (status < 0)) {
HDfprintf(stderr, "Error! %s should be on disk, but was NOT!\n", obj_pathname);
PROCESS_ERROR;
} /* end if */
} else if (strcmp(expected, NOT_FLUSHED) == 0) {
if ((oid > 0) || (status > 0)) {
HDfprintf(stderr, "Error! %s not expected to be flushed, but it was found on disk!\n", obj_pathname);
PROCESS_ERROR;
} /* end if */
} else {
HDfprintf(stderr, "Error! Bad verification parameters. %s is an invalid expected outcome.\n", expected);
PROCESS_ERROR;
} /* end if */
/* Cleanup */
H5E_BEGIN_TRY {
H5Oclose(oid);
H5Fclose(fid);
} H5E_END_TRY;
return SUCCEED;
error:
return FAIL;
} /* flush_verification */
/* UD_hard_delete
* Since the creation function increments the object's reference count, it's
* important to decrement it again when the link is deleted.
*/
static herr_t UD_hard_delete(const char *link_name, hid_t loc_group,
const void *udata, size_t udata_size)
{
haddr_t addr;
hid_t target_obj = -1;
herr_t ret_value = 0;
/* Sanity check; we have already verified the udata's size in the creation
* callback.
*/
if(udata_size != sizeof(haddr_t))
{
ret_value = -1;
goto done;
}
addr = *((const haddr_t *) udata);
/* Open the object this link points to */
target_obj= H5Oopen_by_addr(loc_group, addr);
if(target_obj < 0)
{
ret_value = -1;
goto done;
}
/* Decrement the reference count of the target object */
if(H5Odecr_refcount(target_obj) < 0)
{
ret_value = -1;
goto done;
}
done:
/* Close the target object if we opened it */
if(target_obj >= 0)
H5Oclose(target_obj);
return ret_value;
}
/* UD_hard_create
* The most important thing this callback does is to increment the reference
* count on the target object. Without this step, the object could be
* deleted while this link still pointed to it, resulting in possible data
* corruption!
* The create callback also checks the arguments used to create this link.
* If this function returns a negative value, the call to H5Lcreate_ud()
* will also return failure and the link will not be created.
*/
static herr_t UD_hard_create(const char *link_name, hid_t loc_group,
const void *udata, size_t udata_size, hid_t lcpl_id)
{
haddr_t addr;
hid_t target_obj = -1;
herr_t ret_value = 0;
/* Make sure that the address passed in looks valid */
if(udata_size != sizeof(haddr_t))
{
ret_value = -1;
goto done;
}
addr = *((const haddr_t *) udata);
/* Open the object this link points to so that we can increment
* its reference count. This also ensures that the address passed
* in points to a real object (although this check is not perfect!) */
target_obj= H5Oopen_by_addr(loc_group, addr);
if(target_obj < 0)
{
ret_value = -1;
goto done;
}
/* Increment the reference count of the target object */
if(H5Oincr_refcount(target_obj) < 0)
{
ret_value = -1;
goto done;
}
done:
/* Close the target object if we opened it */
if(target_obj >= 0)
H5Oclose(target_obj);
return ret_value;
}
void FileHDF5::close() {
if (!isOpen())
return;
data.close();
metadata.close();
root.close();
unsigned types = H5F_OBJ_GROUP|H5F_OBJ_DATASET|H5F_OBJ_DATATYPE;
ssize_t obj_count = H5Fget_obj_count(hid, types);
if (obj_count < 0) {
throw H5Exception("FileHDF5::close(): Could not get object count");
}
std::vector<hid_t> objs(static_cast<size_t>(obj_count));
if (obj_count > 0) {
obj_count = H5Fget_obj_ids(hid, types, objs.size(), objs.data());
if (obj_count < 0) {
throw H5Exception("FileHDF5::close(): Could not get objs");
}
}
for (auto obj : objs) {
int ref_count = H5Iget_ref(obj);
for (int j = 0; j < ref_count; j++) {
H5Oclose(obj);
}
}
H5Object::close();
}
int
main (void)
{
hid_t file, space, dset, obj; /* Handles */
herr_t status;
hsize_t dims[1] = {DIM0};
hobj_ref_t wdata[DIM0], /* Write buffer */
*rdata; /* Read buffer */
H5O_type_t objtype;
ssize_t size;
char *name;
int ndims,
i;
/*
* Create a new file using the default properties.
*/
file = H5Fcreate (FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create a dataset with a null dataspace.
*/
space = H5Screate (H5S_NULL);
obj = H5Dcreate (file, "DS2", H5T_STD_I32LE, space, H5P_DEFAULT,
H5P_DEFAULT, H5P_DEFAULT);
status = H5Dclose (obj);
status = H5Sclose (space);
/*
* Create a group.
*/
obj = H5Gcreate (file, "G1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
status = H5Gclose (obj);
/*
* Create references to the previously created objects. Passing -1
* as space_id causes this parameter to be ignored. Other values
* besides valid dataspaces result in an error.
*/
status = H5Rcreate (&wdata[0], file, "G1", H5R_OBJECT, -1);
status = H5Rcreate (&wdata[1], file, "DS2", H5R_OBJECT, -1);
/*
* 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 object references to it.
*/
dset = H5Dcreate (file, DATASET, H5T_STD_REF_OBJ, space, H5P_DEFAULT,
H5P_DEFAULT, H5P_DEFAULT);
status = H5Dwrite (dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT,
wdata);
/*
* Close and release resources.
*/
status = H5Dclose (dset);
status = H5Sclose (space);
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 dataspace and allocate memory for read buffer.
*/
space = H5Dget_space (dset);
ndims = H5Sget_simple_extent_dims (space, dims, NULL);
rdata = (hobj_ref_t *) malloc (dims[0] * sizeof (hobj_ref_t));
/*
* Read the data.
*/
status = H5Dread (dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT,
rdata);
/*
* Output the data to the screen.
*/
for (i=0; i<dims[0]; i++) {
printf ("%s[%d]:\n ->", DATASET, i);
/*
* Open the referenced object, get its name and type.
*/
obj = H5Rdereference (dset, H5R_OBJECT, &rdata[i]);
status = H5Rget_obj_type (dset, H5R_OBJECT, &rdata[i], &objtype);
/*
* Get the length of the name, allocate space, then retrieve
* the name.
*/
size = 1 + H5Iget_name (obj, NULL, 0);
name = (char *) malloc (size);
size = H5Iget_name (obj, name, size);
/*
* Print the object type and close the object.
*/
switch (objtype) {
case H5O_TYPE_GROUP:
printf ("Group");
break;
case H5O_TYPE_DATASET:
printf ("Dataset");
break;
case H5O_TYPE_NAMED_DATATYPE:
printf ("Named Datatype");
}
status = H5Oclose (obj);
/*
* Print the name and deallocate space for the name.
*/
printf (": %s\n", name);
free (name);
}
/*
* Close and release resources.
*/
free (rdata);
status = H5Dclose (dset);
status = H5Sclose (space);
status = H5Fclose (file);
return 0;
}
SWIGEXPORT hid_t JNICALL Java_permafrost_hdf_libhdf_ObjectLibExtensionJNI_JHOopen_1by_1idx(
JNIEnv *jenv,
jclass jcls,
jint loc_id,
jstring group_name,
jint idx_type,
jint order,
jlong n,
jint lapl_id,
jintArray type,
jobjectArray name
) {
jint sz = 0;
char* pGroupName = NULL;
hid_t obj_id = -1;
jint jiType;
char* pName = NULL;
char* tmpName = NULL;
const int szName = 64;
int lenName = 0;
jstring jname;
if (!group_name) {
SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "Null group name.");
return (-1);
} else if (!type) {
SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "Null type array.");
return (-1);
} else if (!name) {
SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "Null object name array.");
return (-1);
}
sz = (*jenv)->GetArrayLength(jenv, type);
if (sz < 1) {
SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "Zero-length type array.");
return (-1);
}
sz = (*jenv)->GetArrayLength(jenv, name);
if (sz < 1) {
SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "Zero-length object name array.");
return (-1);
}
pGroupName = (char *)(*jenv)->GetStringUTFChars(jenv, group_name, 0);
if (!pGroupName) return -1;
obj_id = H5Oopen_by_idx(
(hid_t)loc_id,
pGroupName,
(H5_index_t) idx_type,
(H5_iter_order_t) order,
(hsize_t) n,
(hid_t) lapl_id
);
if (pGroupName) (*jenv)->ReleaseStringUTFChars(jenv, group_name, (const char *) pGroupName);
if (obj_id <= 0) return (obj_id);
jiType = (jint) H5Iget_type(obj_id);
(*jenv)->SetIntArrayRegion(jenv, type, 0, 1, &jiType);
pName = (char*) calloc(szName, sizeof(char));
lenName = H5Iget_name(obj_id, pName, szName-1);
if (lenName >= szName) {
char* tmpName = (char*) realloc(pName, sizeof(char)*lenName+1);
if (!tmpName) {
free(pName);
pName = NULL;
H5Oclose(loc_id);
return (-1);
}
pName = tmpName;
lenName = H5Iget_name(obj_id, pName, lenName);
}
jname = (*jenv)->NewStringUTF(jenv, pName);
(*jenv)->SetObjectArrayElement(jenv, name, 0, jname);
free(pName);
return (obj_id);
}
/*--------------------------------------------------------------*/
static void validateLink(pNXVcontext self, hid_t groupID,
xmlChar *name, xmlChar *target)
{
hid_t objID;
herr_t att;
char linkTarget[512], dataPath[512];
char nxdlPath[512], curPath[512];
/*
set our path for correct error printing
*/
snprintf(nxdlPath,sizeof(nxdlPath),"%s/%s", self->nxdlPath,
(char *)name);
NXVsetLog(self,"nxdlPath",nxdlPath);
H5Iget_name(groupID,curPath,sizeof(curPath));
snprintf(dataPath,sizeof(dataPath),"%s/%s", curPath,
(char *)name);
NXVsetLog(self,"dataPath",dataPath);
/*
log what we are doing
*/
NXVsetLog(self,"sev","debug");
NXVprintLog(self,"message","Validating link %s at %s",
(char *)name, (char *)target);
NXVlog(self);
/*
now we really validate
*/
if(H5LTpath_valid(groupID,(char *)name, 1)){
/*
The positive test means that the link exists and is pointing to
a valid HDF5 object. This is alread good.
*/
objID = H5Oopen(groupID,(char *)name,H5P_DEFAULT);
assert(objID >= 0); /* we just tested for existence, didn't we? */
memset(linkTarget,0,sizeof(linkTarget));
att = H5NXget_attribute_string(groupID,(char *)name,"target",linkTarget);
if(att < 0){
NXVsetLog(self,"sev","error");
H5Iget_name(objID,dataPath,sizeof(dataPath));
NXVsetLog(self,"dataPath",dataPath);
NXVsetLog(self,"message","Link is missing required attribute target");
NXVlog(self);
self->errCount++;
} else {
/*
test that the target attribute really points to something
real. It could be that the link was done right but the
target attribute set sloppily.
*/
if(!H5LTpath_valid(self->fileID,linkTarget,1)){
NXVsetLog(self,"sev","error");
H5Iget_name(objID,dataPath,sizeof(dataPath));
NXVsetLog(self,"dataPath",dataPath);
NXVprintLog(self,"message","Link target %s is invalid",
linkTarget);
NXVlog(self);
self->errCount++;
} else {
validateLinkTarget(self,target,linkTarget);
}
}
H5Oclose(objID);
} else {
NXVsetLog(self,"sev","error");
NXVprintLog(self,"message",
"Required link %s missing or not pointing to an HDF5 object",
(char *)name);
NXVlog(self);
self->errCount++;
}
}
/**
* Reads an array of double attributes from the HDF5 metadata.
* It reads the attributes directly on its binary form directly,
* thus avoiding string conversions.
*
* Important: It allocates the memory for the attributes internally,
* so the caller must free the returned array after using it.
* @param pszAttrName Name of the attribute to be read.
* the attribute name must be the form:
* root attribute name
* SUBDATASET/subdataset attribute name
* @param pdfValues pointer which will store the array of doubles read.
* @param nLen it stores the length of the array read. If NULL it doesn't
* inform the length of the array.
* @return CPLErr CE_None in case of success, CE_Failure in case of failure
*/
CPLErr HDF5Dataset::HDF5ReadDoubleAttr(const char *pszAttrFullPath,
double **pdfValues, int *nLen)
{
CPLString osAttrFullPath(pszAttrFullPath);
// Search for the last "/" in order to get the path to the attribute.
const size_t nSlashPos = osAttrFullPath.find_last_of("/");
CPLString osObjName;
CPLString osAttrName;
// If objects name have been found.
if( nSlashPos != CPLString::npos )
{
// Split Object name (dataset, group).
osObjName = osAttrFullPath.substr(0, nSlashPos);
// Split attribute name.
osAttrName = osAttrFullPath.substr(nSlashPos + 1);
}
else
{
// By default the group is root, and
// the attribute is the full path.
osObjName = "/";
osAttrName = pszAttrFullPath;
}
const hid_t hObjAttrID = H5Oopen(hHDF5, osObjName.c_str(), H5P_DEFAULT);
CPLErr retVal = CE_Failure;
if(hObjAttrID < 0)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Object %s could not be opened", pszAttrFullPath);
retVal = CE_Failure;
}
else
{
// Open attribute handler by name, from the object handler opened
// earlier.
const hid_t hAttrID = H5Aopen_name(hObjAttrID, osAttrName.c_str());
// Check for errors opening the attribute.
if( hAttrID < 0 )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Attribute %s could not be opened", pszAttrFullPath);
retVal = CE_Failure;
}
else
{
const hid_t hAttrTypeID = H5Aget_type(hAttrID);
const hid_t hAttrNativeType =
H5Tget_native_type(hAttrTypeID, H5T_DIR_DEFAULT);
const hid_t hAttrSpace = H5Aget_space(hAttrID);
hsize_t nSize[64] = {};
const unsigned int nAttrDims =
H5Sget_simple_extent_dims(hAttrSpace, nSize, nullptr);
if( !H5Tequal(H5T_NATIVE_DOUBLE, hAttrNativeType) )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Attribute %s is not of type double",
pszAttrFullPath);
retVal = CE_Failure;
}
else
{
// Get the amount of elements.
unsigned int nAttrElmts = 1;
for( hsize_t i = 0; i < nAttrDims; i++ )
{
// For multidimensional attributes
nAttrElmts *= static_cast<unsigned int>(nSize[i]);
}
if(nLen != nullptr)
*nLen = nAttrElmts;
*pdfValues = static_cast<double *>(
CPLMalloc(nAttrElmts * sizeof(double)));
// Read the attribute contents
if( H5Aread(hAttrID, hAttrNativeType, *pdfValues) < 0 )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Attribute %s could not be opened",
pszAttrFullPath);
retVal = CE_Failure;
}
else
{
retVal = CE_None;
}
}
H5Tclose(hAttrNativeType);
H5Tclose(hAttrTypeID);
H5Sclose(hAttrSpace);
H5Aclose(hAttrID);
}
H5Oclose(hObjAttrID);
}
return retVal;
}
int VsFilter::visitLinks(hid_t locId, const char* name,
const H5L_info_t *linfo, void* opdata) {
VsLog::debugLog() <<"VsFilter::visitLinks() - looking at object " <<name <<std::endl;
switch (linfo->type) {
case H5L_TYPE_HARD: {
H5O_info_t objinfo;
/* Stat the object */
if(H5Oget_info_by_name(locId, name, &objinfo, H5P_DEFAULT) < 0) {
VsLog::errorLog() <<"VsFilter::visitLinks() - unable to open object with name " <<name <<std::endl;
VsLog::errorLog() <<"VsFilter::visitLinks() - this object and all children will be dropped." <<std::endl;
return 0;
}
switch(objinfo.type)
{
case H5O_TYPE_GROUP:
return visitGroup( locId, name, opdata );
break;
case H5O_TYPE_DATASET:
return visitDataset( locId, name, opdata );
break;
default:
VsLog::debugLog() << "VsFilter::visitLinks: node '" << name <<
"' has an unknown type " << objinfo.type << std::endl;
break;
}
}
break;
//end of case H5L_TYPE_HARD
case H5L_TYPE_EXTERNAL: {
char *targbuf = (char*) malloc( linfo->u.val_size );
if (H5Lget_val(locId, name, targbuf, linfo->u.val_size, H5P_DEFAULT) < 0) {
VsLog::errorLog() <<"VsFilter::visitLinks() - unable to open external link with name " <<targbuf <<std::endl;
VsLog::errorLog() <<"VsFilter::visitLinks() - this object and all children will be dropped." <<std::endl;
return 0;
}
const char *filename;
const char *targname;
if (H5Lunpack_elink_val(targbuf, linfo->u.val_size, 0, &filename, &targname) < 0) {
VsLog::errorLog() <<"VsFilter::visitLinks() - unable to open external file with name " <<filename <<std::endl;
VsLog::errorLog() <<"VsFilter::visitLinks() - this object and all children will be dropped." <<std::endl;
return 0;
}
VsLog::debugLog() << "VsFilter::visitLinks(): node '" << name << "' is an external link." << std::endl;
VsLog::debugLog() << "VsFilter::visitLinks(): node '" << targname << "' is an external target group." << std::endl;
free(targbuf);
targbuf = NULL;
// Get info of the linked object.
H5O_info_t objinfo;
#ifndef H5_USE_16_API
hid_t obj_id = H5Oopen(locId, name, H5P_DEFAULT);
#else
hid_t obj_id = H5Oopen(locId, name);
#endif
if (obj_id < 0) {
VsLog::errorLog() <<"VsFilter::visitLinks() - unable to get id for external object " <<name <<std::endl;
VsLog::errorLog() <<"VsFilter::visitLinks() - this object and all children will be dropped." <<std::endl;
return 0;
}
//Test-open the linked object
if (H5Oget_info (obj_id, &objinfo) < 0) {
VsLog::errorLog() <<"VsFilter::visitLinks() - unable to open external object " <<name <<std::endl;
VsLog::errorLog() <<"VsFilter::visitLinks() - this object and all children will be dropped." <<std::endl;
return 0;
}
//Close the linked object to release hdf5 id
H5Oclose( obj_id );
//Finally, decide what to do depending on what type of object this is
switch(objinfo.type)
{
case H5O_TYPE_GROUP:
return visitGroup( locId, name, opdata );
break;
case H5O_TYPE_DATASET:
return visitDataset( locId, name, opdata );
break;
default:
VsLog::debugLog() << "VsFilter::visitLinks: node '" << name <<
"' has an unknown type " << objinfo.type << std::endl;
break;
}
}
break;
//END OF CASE H5L_TYPE_EXTERNAL
default:
VsLog::debugLog() << "VsFilter::visitLinks: node '" << name <<
"' has an unknown object type " << linfo->type << std::endl;
break;
}
return 0;
}
/*-------------------------------------------------------------------------
* Function: refresh_verification
*
* Purpose: This function opens the specified object, and checks to see
* that is does not have any attributes on it. It then sends
* a signal to the main process, which will flush the object
* (putting an attribute on the object on disk). This function
* will then refresh the object, and verify that it has picked
* up the new metadata reflective of the added attribute.
*
* Return: 0 on Success, 1 on Failure
*
* Programmer: Mike McGreevy
* July 16, 2010
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
herr_t refresh_verification(const char * obj_pathname)
{
/* Variables */
hid_t oid,fid,status = 0;
H5O_info_t flushed_oinfo;
H5O_info_t refreshed_oinfo;
/* Open Object */
if ((fid = H5Fopen(FILENAME, H5F_ACC_SWMR_READ, H5P_DEFAULT)) < 0) PROCESS_ERROR;
if ((oid = H5Oopen(fid, obj_pathname, H5P_DEFAULT)) < 0) PROCESS_ERROR;
/* Get Object info */
if ((status = H5Oget_info(oid, &flushed_oinfo)) < 0) PROCESS_ERROR;
/* Make sure there are no attributes on the object. This is just a sanity
check to ensure we didn't erroneously flush the attribute before
starting the verification. */
if (flushed_oinfo.num_attrs != 0) PROCESS_ERROR;
/* Send Signal to MAIN PROCESS indicating that it can go ahead and modify the
object. */
send_signal(SIGNAL_BETWEEN_PROCESSES_1, NULL, NULL);
/* Wait for Signal from MAIN PROCESS indicating that it's modified the
object and we can run verification now. */
if (wait_for_signal(SIGNAL_BETWEEN_PROCESSES_2) < 0) PROCESS_ERROR;
/* Get object info again. This will NOT reflect what's on disk, only what's
in the cache. Thus, all values will be unchanged from above, despite
newer information being on disk. */
if ((status = H5Oget_info(oid, &refreshed_oinfo)) < 0) PROCESS_ERROR;
/* Verify that before doing a refresh, getting the object info returns stale
information. (i.e., unchanged from above, despite new info on disk). */
if (flushed_oinfo.addr != refreshed_oinfo.addr) PROCESS_ERROR;
if (flushed_oinfo.type != refreshed_oinfo.type) PROCESS_ERROR;
if (flushed_oinfo.hdr.version != refreshed_oinfo.hdr.version) PROCESS_ERROR;
if (flushed_oinfo.hdr.flags != refreshed_oinfo.hdr.flags) PROCESS_ERROR;
if (flushed_oinfo.num_attrs != refreshed_oinfo.num_attrs) PROCESS_ERROR;
if (flushed_oinfo.hdr.nmesgs != refreshed_oinfo.hdr.nmesgs) PROCESS_ERROR;
if (flushed_oinfo.hdr.nchunks != refreshed_oinfo.hdr.nchunks) PROCESS_ERROR;
if (flushed_oinfo.hdr.space.total != refreshed_oinfo.hdr.space.total) PROCESS_ERROR;
/* Refresh object */
/* The H5*refresh function called depends on which object we are trying
* to refresh. (MIKE: add desired refresh call as parameter so adding new
* test cases is easy). */
if ((strcmp(obj_pathname, D1) == 0) ||
(strcmp(obj_pathname, D2) == 0)) {
if (H5Drefresh(oid) < 0) PROCESS_ERROR;
} /* end if */
else if ((strcmp(obj_pathname, G1) == 0) ||
(strcmp(obj_pathname, G2) == 0)) {
if (H5Grefresh(oid) < 0) PROCESS_ERROR;
} /* end if */
else if ((strcmp(obj_pathname, T1) == 0) ||
(strcmp(obj_pathname, T2) == 0)) {
if (H5Trefresh(oid) < 0) PROCESS_ERROR;
} /* end if */
else if ((strcmp(obj_pathname, D3) == 0) ||
(strcmp(obj_pathname, G3) == 0) ||
(strcmp(obj_pathname, T3) == 0)) {
if (H5Orefresh(oid) < 0) PROCESS_ERROR;
} /* end if */
else {
HDfprintf(stdout, "Error. %s is an unrecognized object.\n", obj_pathname);
PROCESS_ERROR;
} /* end else */
/* Get object info. This should now accurately reflect the refreshed object on disk. */
if ((status = H5Oget_info(oid, &refreshed_oinfo)) < 0) PROCESS_ERROR;
/* Confirm following attributes are the same: */
if (flushed_oinfo.addr != refreshed_oinfo.addr) PROCESS_ERROR;
if (flushed_oinfo.type != refreshed_oinfo.type) PROCESS_ERROR;
if (flushed_oinfo.hdr.version != refreshed_oinfo.hdr.version) PROCESS_ERROR;
if (flushed_oinfo.hdr.flags != refreshed_oinfo.hdr.flags) PROCESS_ERROR;
/* Confirm following attributes are different */
if (flushed_oinfo.num_attrs == refreshed_oinfo.num_attrs) PROCESS_ERROR;
if (flushed_oinfo.hdr.nmesgs == refreshed_oinfo.hdr.nmesgs) PROCESS_ERROR;
if (flushed_oinfo.hdr.nchunks == refreshed_oinfo.hdr.nchunks) PROCESS_ERROR;
if (flushed_oinfo.hdr.space.total == refreshed_oinfo.hdr.space.total) PROCESS_ERROR;
/* Close objects */
if (H5Oclose(oid) < 0) PROCESS_ERROR;
if (H5Fclose(fid) < 0) PROCESS_ERROR;
/* Return */
return SUCCEED;
error:
return FAIL;
} /* refresh_verification */
void H5ReferenceData::printData(std::ostream & os, const unsigned int pos, const unsigned int indentLevel) const
{
char * cdata = static_cast<char *>(data) + offset + pos * (stride ? stride : dataSize);
void ** ref = &(((void **)cdata)[0]);
hid_t file = getFile().getH5Id();
hid_t obj = H5Rdereference(file, datasetReference ? H5R_DATASET_REGION : H5R_OBJECT, ref);
if (obj < 0)
{
os << "NULL";
return;
}
ssize_t size = H5Rget_name(file, datasetReference ? H5R_DATASET_REGION : H5R_OBJECT, ref, 0, 0);
char * name = 0;
H5O_info_t info;
if (size != -1)
{
name = new char[size + 1];
H5Rget_name(file, datasetReference ? H5R_DATASET_REGION : H5R_OBJECT, ref, name, size + 1);
if (datasetReference == H5R_OBJECT)
{
H5Oget_info(obj, &info);
H5Oclose(obj);
switch (info.type)
{
case H5O_TYPE_GROUP:
os << "GROUP ";
break;
case H5O_TYPE_DATASET:
os << "DATASET ";
break;
case H5O_TYPE_NAMED_DATATYPE:
os << "DATATYPE ";
break;
case H5O_TYPE_UNKNOWN:
default:
if (size != -1)
{
delete[] name;
}
throw H5Exception(__LINE__, __FILE__, _("Unknown HDF5 object"));
}
os << (haddr_t)(*ref) << " " << name;
}
else
{
hid_t space = H5Rget_region(file, H5R_DATASET_REGION, ref);
hssize_t npoints = H5Sget_select_elem_npoints(space);
hsize_t ndims = H5Sget_simple_extent_dims(space, 0, 0);
H5Oclose(obj);
os << "DATASET " << name << " {";
if (npoints >= 0)
{
const hsize_t N = ndims * npoints;
hsize_t * buf = new hsize_t[N];
herr_t err = H5Sget_select_elem_pointlist(space, 0, npoints, buf);
for (hssize_t i = 0; i < (hssize_t)N; i += ndims)
{
os << "(";
for (unsigned int j = 0; j < ndims - 1; j++)
{
os << buf[i + j] << ",";
}
os << buf[i + ndims - 1] << ")";
if (i != N - ndims)
{
os << ", ";
}
else
{
os << "}";
}
}
delete[] buf;
}
else
{
hssize_t nblocks = H5Sget_select_hyper_nblocks(space);
if (nblocks >= 0)
{
const hsize_t N = 2 * ndims * nblocks;
hsize_t * buf = new hsize_t[N];
herr_t err = H5Sget_select_hyper_blocklist(space, 0, nblocks, buf);
for (hssize_t i = 0; i < (hssize_t)N; i += 2 * ndims)
{
os << "(";
for (unsigned int j = 0; j < ndims - 1; j++)
{
os << buf[i + j] << ",";
}
os << buf[i + ndims - 1] << ")-(";
for (unsigned int j = 0; j < ndims - 1; j++)
{
os << buf[i + ndims + j] << ",";
}
os << buf[i + 2 * ndims - 1] << ")";
if (i != N - 2 * ndims)
{
os << ", ";
}
else
{
os << "}";
}
}
delete[] buf;
}
}
H5Sclose(space);
}
delete[] name;
}
}
int do_copy_refobjs(hid_t fidin,
hid_t fidout,
trav_table_t *travt,
pack_opt_t *options) /* repack options */
{
hid_t grp_in = (-1); /* read group ID */
hid_t grp_out = (-1); /* write group ID */
hid_t dset_in = (-1); /* read dataset ID */
hid_t dset_out = (-1); /* write dataset ID */
hid_t type_in = (-1); /* named type ID */
hid_t dcpl_id = (-1); /* dataset creation property list ID */
hid_t space_id = (-1); /* space ID */
hid_t ftype_id = (-1); /* file data type ID */
hid_t mtype_id = (-1); /* memory data type ID */
size_t msize; /* memory size of memory type */
hsize_t nelmts; /* number of elements in dataset */
int rank; /* rank of dataset */
hsize_t dims[H5S_MAX_RANK]; /* dimensions of dataset */
unsigned int i, j;
int k;
named_dt_t *named_dt_head=NULL; /* Pointer to the stack of named datatypes
copied */
/*-------------------------------------------------------------------------
* browse
*-------------------------------------------------------------------------
*/
for(i = 0; i < travt->nobjs; i++) {
switch(travt->objs[i].type)
{
/*-------------------------------------------------------------------------
* H5TRAV_TYPE_GROUP
*-------------------------------------------------------------------------
*/
case H5TRAV_TYPE_GROUP:
/*-------------------------------------------------------------------------
* copy referenced objects in attributes
*-------------------------------------------------------------------------
*/
if((grp_out = H5Gopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
goto error;
if((grp_in = H5Gopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
goto error;
if(copy_refs_attr(grp_in, grp_out, options, travt, fidout) < 0)
goto error;
if(H5Gclose(grp_out) < 0)
goto error;
if(H5Gclose(grp_in) < 0)
goto error;
/*-------------------------------------------------------------------------
* check for hard links
*-------------------------------------------------------------------------
*/
if(travt->objs[i].nlinks)
for(j = 0; j < travt->objs[i].nlinks; j++)
H5Lcreate_hard(fidout, travt->objs[i].name, H5L_SAME_LOC, travt->objs[i].links[j].new_name, H5P_DEFAULT, H5P_DEFAULT);
break;
/*-------------------------------------------------------------------------
* H5TRAV_TYPE_DATASET
*-------------------------------------------------------------------------
*/
case H5TRAV_TYPE_DATASET:
if((dset_in = H5Dopen2(fidin, travt->objs[i].name, H5P_DEFAULT)) < 0)
goto error;
if((space_id = H5Dget_space(dset_in)) < 0)
goto error;
if((ftype_id = H5Dget_type(dset_in)) < 0)
goto error;
if((dcpl_id = H5Dget_create_plist(dset_in)) < 0)
goto error;
if((rank = H5Sget_simple_extent_ndims(space_id)) < 0)
goto error;
if(H5Sget_simple_extent_dims(space_id, dims, NULL) < 0)
goto error;
nelmts = 1;
for(k = 0; k < rank; k++)
nelmts *= dims[k];
if((mtype_id = h5tools_get_native_type(ftype_id)) < 0)
goto error;
if((msize = H5Tget_size(mtype_id)) == 0)
goto error;
/*-------------------------------------------------------------------------
* check if the dataset creation property list has filters that
* are not registered in the current configuration
* 1) the external filters GZIP and SZIP might not be available
* 2) the internal filters might be turned off
*-------------------------------------------------------------------------
*/
if(h5tools_canreadf(NULL, dcpl_id) == 1) {
/*-------------------------------------------------------------------------
* test for a valid output dataset
*-------------------------------------------------------------------------
*/
dset_out = FAIL;
/*-------------------------------------------------------------------------
* object references are a special case
* we cannot just copy the buffers, but instead we recreate the reference
*-------------------------------------------------------------------------
*/
if(H5Tequal(mtype_id, H5T_STD_REF_OBJ)) {
hid_t refobj_id;
hobj_ref_t *refbuf = NULL; /* buffer for object references */
hobj_ref_t *buf = NULL;
const char* refname;
unsigned u;
/*-------------------------------------------------------------------------
* read to memory
*-------------------------------------------------------------------------
*/
if(nelmts) {
buf = (hobj_ref_t *)HDmalloc((unsigned)(nelmts * msize));
if(buf==NULL) {
printf("cannot read into memory\n" );
goto error;
} /* end if */
if(H5Dread(dset_in, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
goto error;
refbuf = (hobj_ref_t*) HDcalloc((unsigned)nelmts, msize);
if(refbuf == NULL){
printf("cannot allocate memory\n" );
goto error;
} /* end if */
for(u = 0; u < nelmts; u++) {
H5E_BEGIN_TRY {
if((refobj_id = H5Rdereference(dset_in, H5R_OBJECT, &buf[u])) < 0)
continue;
} H5E_END_TRY;
/* get the name. a valid name could only occur
* in the second traversal of the file
*/
if((refname = MapIdToName(refobj_id, travt)) != NULL) {
/* create the reference, -1 parameter for objects */
if(H5Rcreate(&refbuf[u], fidout, refname, H5R_OBJECT, -1) < 0)
goto error;
if(options->verbose)
{
printf(FORMAT_OBJ,"dset",travt->objs[i].name );
printf("object <%s> object reference created to <%s>\n",
travt->objs[i].name,
refname);
}
} /*refname*/
H5Oclose(refobj_id);
} /* u */
} /*nelmts*/
/*-------------------------------------------------------------------------
* create/write dataset/close
*-------------------------------------------------------------------------
*/
if((dset_out = H5Dcreate2(fidout, travt->objs[i].name, mtype_id, space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT)) < 0)
goto error;
if(nelmts)
if(H5Dwrite(dset_out, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, refbuf) < 0)
goto error;
if(buf)
HDfree(buf);
if(refbuf)
HDfree(refbuf);
/*------------------------------------------------------
* copy attrs
*----------------------------------------------------*/
if(copy_attr(dset_in, dset_out, &named_dt_head, travt, options) < 0)
goto error;
} /*H5T_STD_REF_OBJ*/
/*-------------------------------------------------------------------------
* dataset region references
*-------------------------------------------------------------------------
*/
else if(H5Tequal(mtype_id, H5T_STD_REF_DSETREG))
{
hid_t refobj_id;
hdset_reg_ref_t *refbuf = NULL; /* input buffer for region references */
hdset_reg_ref_t *buf = NULL; /* output buffer */
const char* refname;
unsigned u;
/*-------------------------------------------------------------------------
* read input to memory
*-------------------------------------------------------------------------
*/
if(nelmts) {
buf = (hdset_reg_ref_t *)HDmalloc((unsigned)(nelmts * msize));
if(buf == NULL) {
printf("cannot read into memory\n");
goto error;
} /* end if */
if(H5Dread(dset_in, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0)
goto error;
/*-------------------------------------------------------------------------
* create output
*-------------------------------------------------------------------------
*/
refbuf = (hdset_reg_ref_t *)HDcalloc(sizeof(hdset_reg_ref_t), (size_t)nelmts); /*init to zero */
if(refbuf == NULL) {
printf("cannot allocate memory\n");
goto error;
} /* end if */
for(u = 0; u < nelmts; u++) {
H5E_BEGIN_TRY {
if((refobj_id = H5Rdereference(dset_in, H5R_DATASET_REGION, &buf[u])) < 0)
continue;
} H5E_END_TRY;
/* get the name. a valid name could only occur
* in the second traversal of the file
*/
if((refname = MapIdToName(refobj_id, travt)) != NULL) {
hid_t region_id; /* region id of the referenced dataset */
if((region_id = H5Rget_region(dset_in, H5R_DATASET_REGION, &buf[u])) < 0)
goto error;
/* create the reference, we need the space_id */
if(H5Rcreate(&refbuf[u], fidout, refname, H5R_DATASET_REGION, region_id) < 0)
goto error;
if(H5Sclose(region_id) < 0)
goto error;
if(options->verbose)
{
printf(FORMAT_OBJ,"dset",travt->objs[i].name );
printf("object <%s> region reference created to <%s>\n",
travt->objs[i].name,
refname);
}
} /*refname*/
H5Oclose(refobj_id);
} /* u */
} /*nelmts*/
/*-------------------------------------------------------------------------
* create/write dataset/close
*-------------------------------------------------------------------------
*/
if((dset_out = H5Dcreate2(fidout, travt->objs[i].name, mtype_id, space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT)) < 0)
goto error;
if(nelmts)
if(H5Dwrite(dset_out, mtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, refbuf) < 0)
goto error;
if(buf)
HDfree(buf);
if(refbuf)
HDfree(refbuf);
/*-----------------------------------------------------
* copy attrs
*----------------------------------------------------*/
if(copy_attr(dset_in, dset_out, &named_dt_head, travt, options) < 0)
goto error;
} /* H5T_STD_REF_DSETREG */
/*-------------------------------------------------------------------------
* not references, open previously created object in 1st traversal
*-------------------------------------------------------------------------
*/
else {
if((dset_out = H5Dopen2(fidout, travt->objs[i].name, H5P_DEFAULT)) < 0)
goto error;
} /* end else */
assert(dset_out != FAIL);
/*-------------------------------------------------------------------------
* copy referenced objects in attributes
*-------------------------------------------------------------------------
*/
if(copy_refs_attr(dset_in, dset_out, options, travt, fidout) < 0)
goto error;
/*-------------------------------------------------------------------------
* check for hard links
*-------------------------------------------------------------------------
*/
if(travt->objs[i].nlinks)
for(j = 0; j < travt->objs[i].nlinks; j++)
H5Lcreate_hard(fidout, travt->objs[i].name, H5L_SAME_LOC, travt->objs[i].links[j].new_name, H5P_DEFAULT, H5P_DEFAULT);
if(H5Dclose(dset_out) < 0)
goto error;
} /*can_read*/
hid_t dat1Reopen( hid_t file_id, unsigned int flags, hid_t fapl,
int *status ){
/* Local Variables; */
HDSLoc **loc;
HDSLoc **loclist;
char **paths;
char file[EMS__SZMSG+1];
char path[EMS__SZMSG+1];
hid_t *file_ids;
hid_t id;
int *isgroup;
int iloc;
int nlev;
int nloc;
ssize_t size;
/* Return immediately if an error has already occurred. */
if( *status != SAI__OK ) return file_id;
/* Get a list of any active locators associated with the file. Also get a
list of file_ids for the same file that have associated locators. */
hds1GetLocators( file_id, &nloc, &loclist, &file_ids, status );
/* Check that none of the locators are mapped. */
if( *status == SAI__OK ) {
loc = loclist;
for( iloc = 0; iloc < nloc; iloc++,loc++ ) {
if( (*loc)->regpntr ) {
hdsTrace( (*loc), &nlev, path, file, status, sizeof(path), sizeof(file) );
*status = DAT__PRMAP;
emsRepf( " ", "hdsOpen: Cannot re-open '%s' in read-write mode "
"since '%s' is currently mapped.", status, file, path );
break;
}
}
}
/* Store the path to the HDF5 object associated with each active locator,
and also a flag indicating if the HDF5 object is a group or dataset.
Then close the HDF5 objects. */
paths = MEM_CALLOC( nloc, sizeof( *paths ) );
isgroup = MEM_CALLOC( nloc, sizeof( *isgroup ) );
if( paths && isgroup && *status == SAI__OK ) {
loc = loclist;
for( iloc = 0; iloc < nloc; iloc++,loc++ ) {
if( (*loc)->group_id ) {
isgroup[ iloc ] = 1;
id = (*loc)->group_id;
} else {
isgroup[ iloc ] = 0;
id = (*loc)->dataset_id;
}
if( id ) {
size = H5Iget_name( id, NULL, 0 );
paths[ iloc ] = MEM_CALLOC( size + 1, 1 );
H5Iget_name( id, paths[ iloc ], size + 1 );
} else {
hdsTrace( (*loc), &nlev, path, file, status, sizeof(path), sizeof(file) );
*status = DAT__FATAL;
emsRepf( " ", "hdsOpen: Locator for '%s.%s' has no group or "
"dataset so cannot be reopened.", status, file, path );
break;
}
if( H5Oclose( id ) < 0 ) {
hdsTrace( (*loc), &nlev, path, file, status, sizeof(path), sizeof(file) );
*status = DAT__FATAL;
dat1H5EtoEMS( status );
emsRepf( " ", "hdsOpen: Failed to close HDF5 object for '%s.%s'.",
status, file, path );
break;
}
}
}
/* Get the path for the file. */
H5Fget_name( file_id, path, sizeof(path) );
/* Close all HDF5 file_ids associated with file. */
if( *status == SAI__OK ) {
int this_closed = 0;
int i = -1;
while( file_ids[ ++i ] ) {
if( file_ids[ i ] == file_id ) this_closed = 1;
if( H5Fclose( file_ids[ i ] ) < 0 ) {
*status = DAT__FATAL;
dat1H5EtoEMS( status );
emsRepf( " ", "hdsOpen: Failed to close file '%s' prior to "
"re-opening it.", status, path );
break;
}
}
/* Close the supplied file_id if it has not already been closed. */
if( !this_closed ) {
if( H5Fclose( file_id ) < 0 ) {
*status = DAT__FATAL;
dat1H5EtoEMS( status );
emsRepf( " ", "hdsOpen: Failed to close file '%s' prior to "
"re-opening it.", status, path );
}
}
}
/* Re-open it. */
if( *status == SAI__OK ) {
file_id = H5Fopen( path, flags, fapl );
if( file_id < 0 ) {
*status = DAT__FATAL;
dat1H5EtoEMS( status );
emsRepf( " ", "hdsOpen: Failed to reopen file '%s'.",
status, path );
}
}
/* Update the file, group and dataset id in each locator. */
if( *status == SAI__OK ) {
loc = loclist;
for( iloc = 0; iloc < nloc; iloc++,loc++ ) {
hds1SetFileId( (*loc), file_id, status );
if( isgroup[ iloc ] ) {
(*loc)->group_id = H5Gopen2( file_id, paths[ iloc ], H5P_DEFAULT );
} else {
(*loc)->dataset_id = H5Dopen2( file_id, paths[ iloc ], H5P_DEFAULT );
}
}
}
/* Free resources. */
if( paths ) {
for( iloc = 0; iloc < nloc; iloc++ ) {
MEM_FREE( paths[ iloc ] );
}
MEM_FREE( paths );
}
if( isgroup ) MEM_FREE( isgroup );
if( loclist ) MEM_FREE( loclist );
if( file_ids ) MEM_FREE( file_ids );
/* Return the new file id. */
return file_id;
}
