1930 lines
51 KiB
C
1930 lines
51 KiB
C
/*---------------------------------------------------------------------------
|
|
NeXus - Neutron & X-ray Common Data Format
|
|
|
|
Application Program Interface (HDF5) Routines
|
|
|
|
Copyright (C) 1997-2006 Mark Koennecke, Przemek Klosowski
|
|
|
|
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 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
For further information, see <http://www.neutron.anl.gov/NeXus/>
|
|
|
|
----------------------------------------------------------------------------*/
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#include "napi.h"
|
|
#include "napi5.h"
|
|
|
|
#define NX_UNKNOWN_GROUP "" /* for when no NX_class attr */
|
|
|
|
extern void *NXpData;
|
|
|
|
typedef struct __NexusFile5 {
|
|
struct iStack5 {
|
|
char irefn[1024];
|
|
int iVref;
|
|
int iCurrentIDX;
|
|
} iStack5[NXMAXSTACK];
|
|
struct iStack5 iAtt5;
|
|
int iFID;
|
|
int iCurrentG;
|
|
int iCurrentD;
|
|
int iCurrentS;
|
|
int iCurrentT;
|
|
int iCurrentA;
|
|
int iNX;
|
|
int iNXID;
|
|
int iStackPtr;
|
|
char *iCurrentLGG;
|
|
char *iCurrentLD;
|
|
char name_ref[1024];
|
|
char name_tmp[1024];
|
|
char iAccess[2];
|
|
} NexusFile5, *pNexusFile5;
|
|
|
|
/*
|
|
forward declaration of NX5closegroup in order to get rid of a nasty
|
|
warning
|
|
*/
|
|
NXstatus NX5closegroup(NXhandle fid);
|
|
/*-------------------------------------------------------------------*/
|
|
static void ignoreError(void *data, char *text)
|
|
{
|
|
}
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
|
|
static pNexusFile5 NXI5assert(NXhandle fid)
|
|
{
|
|
pNexusFile5 pRes;
|
|
|
|
assert(fid != NULL);
|
|
pRes = (pNexusFile5) fid;
|
|
assert(pRes->iNXID == NX5SIGNATURE);
|
|
return pRes;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
|
|
static void NXI5KillDir(pNexusFile5 self)
|
|
{
|
|
self->iStack5[self->iStackPtr].iCurrentIDX = 0;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
|
|
static void NXI5KillAttDir(pNexusFile5 self)
|
|
{
|
|
self->iAtt5.iCurrentIDX = 0;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------*/
|
|
static void buildCurrentPath(pNexusFile5 self, char *pathBuffer,
|
|
int pathBufferLen)
|
|
{
|
|
int length;
|
|
|
|
memset(pathBuffer, 0, pathBufferLen);
|
|
if (self->iCurrentG != 0) {
|
|
strcpy(pathBuffer, "/");
|
|
if (strlen(self->name_ref) + 1 < pathBufferLen) {
|
|
strcat(pathBuffer, self->name_ref);
|
|
}
|
|
}
|
|
if (self->iCurrentD != 0) {
|
|
strcat(pathBuffer, "/");
|
|
if (strlen(self->iCurrentLD) + strlen(pathBuffer) < pathBufferLen) {
|
|
strcat(pathBuffer, self->iCurrentLD);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
|
|
Definition of NeXus API
|
|
|
|
--------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5open(CONSTCHAR * filename, NXaccess am, NXhandle * pHandle)
|
|
{
|
|
hid_t attr1, aid1, aid2, iVID;
|
|
pNexusFile5 pNew = NULL;
|
|
char pBuffer[512];
|
|
char *time_buffer = NULL;
|
|
char version_nr[10];
|
|
int iRet;
|
|
unsigned int vers_major, vers_minor, vers_release, am1;
|
|
hid_t fapl = -1;
|
|
int mdc_nelmts;
|
|
#ifdef H5_WANT_H5_V1_4_COMPAT
|
|
int rdcc_nelmts;
|
|
#else
|
|
size_t rdcc_nelmts;
|
|
#endif
|
|
size_t rdcc_nbytes;
|
|
double rdcc_w0;
|
|
|
|
/* turn off the automatic HDF error handling */
|
|
H5Eset_auto(NULL, NULL);
|
|
#ifdef USE_FTIME
|
|
struct timeb timeb_struct;
|
|
#endif
|
|
|
|
*pHandle = NULL;
|
|
|
|
pNew = (pNexusFile5) malloc(sizeof(NexusFile5));
|
|
if (!pNew) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: no memory to create File datastructure");
|
|
return NX_ERROR;
|
|
}
|
|
memset(pNew, 0, sizeof(NexusFile5));
|
|
|
|
|
|
/* start HDF5 interface */
|
|
if (am == NXACC_CREATE5) {
|
|
fapl = H5Pcreate(H5P_FILE_ACCESS);
|
|
iRet =
|
|
H5Pget_cache(fapl, &mdc_nelmts, &rdcc_nelmts, &rdcc_nbytes,
|
|
&rdcc_w0);
|
|
rdcc_nbytes = (size_t) nx_cacheSize;
|
|
iRet =
|
|
H5Pset_cache(fapl, mdc_nelmts, rdcc_nelmts, rdcc_nbytes, rdcc_w0);
|
|
/*
|
|
setting the close degree is absolutely necessary in HDF5
|
|
versions > 1.6. If you use a lessere version and the compiler
|
|
complains, comment it out but keep this in mind.
|
|
*/
|
|
H5Pset_fclose_degree(fapl, H5F_CLOSE_STRONG);
|
|
am1 = H5F_ACC_TRUNC;
|
|
pNew->iFID = H5Fcreate(filename, am1, H5P_DEFAULT, fapl);
|
|
} else {
|
|
if (am == NXACC_READ) {
|
|
am1 = H5F_ACC_RDONLY;
|
|
} else {
|
|
am1 = H5F_ACC_RDWR;
|
|
}
|
|
fapl = H5Pcreate(H5P_FILE_ACCESS);
|
|
H5Pset_fclose_degree(fapl, H5F_CLOSE_STRONG);
|
|
pNew->iFID = H5Fopen(filename, am1, fapl);
|
|
}
|
|
if (pNew->iFID <= 0) {
|
|
sprintf(pBuffer, "ERROR: cannot open file: %s", filename);
|
|
NXIReportError(NXpData, pBuffer);
|
|
free(pNew);
|
|
return NX_ERROR;
|
|
}
|
|
if (fapl != -1) {
|
|
H5Pclose(fapl);
|
|
}
|
|
|
|
/*
|
|
* need to create global attributes file_name file_time NeXus_version
|
|
* at some point for new files
|
|
*/
|
|
if (am1 != H5F_ACC_RDONLY) {
|
|
iVID = H5Gopen(pNew->iFID, "/");
|
|
aid2 = H5Screate(H5S_SCALAR);
|
|
aid1 = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(aid1, strlen(NEXUS_VERSION));
|
|
if (am1 == H5F_ACC_RDWR) {
|
|
H5Adelete(iVID, "NeXus_version");
|
|
}
|
|
attr1 = H5Acreate(iVID, "NeXus_version", aid1, aid2, H5P_DEFAULT);
|
|
if (attr1 < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store NeXus_version attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
if (H5Awrite(attr1, aid1, NEXUS_VERSION) < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store NeXus_version attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
/* Close attribute dataspace */
|
|
iRet = H5Tclose(aid1);
|
|
iRet = H5Sclose(aid2);
|
|
/* Close attribute */
|
|
iRet = H5Aclose(attr1);
|
|
H5Gclose(iVID);
|
|
}
|
|
if (am1 == H5F_ACC_TRUNC) {
|
|
iVID = H5Gopen(pNew->iFID, "/");
|
|
aid2 = H5Screate(H5S_SCALAR);
|
|
aid1 = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(aid1, strlen(filename));
|
|
attr1 = H5Acreate(iVID, "file_name", aid1, aid2, H5P_DEFAULT);
|
|
if (attr1 < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store file_name attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
if (H5Awrite(attr1, aid1, (char *) filename) < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store file_name attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
iRet = H5Tclose(aid1);
|
|
iRet = H5Sclose(aid2);
|
|
iRet = H5Aclose(attr1);
|
|
/* ------- library version ------ */
|
|
H5get_libversion(&vers_major, &vers_minor, &vers_release);
|
|
sprintf(version_nr, "%d.%d.%d", vers_major, vers_minor, vers_release);
|
|
aid2 = H5Screate(H5S_SCALAR);
|
|
aid1 = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(aid1, strlen(version_nr));
|
|
attr1 = H5Acreate(iVID, "HDF5_Version", aid1, aid2, H5P_DEFAULT);
|
|
if (attr1 < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store file_name attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
if (H5Awrite(attr1, aid1, (char *) version_nr) < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store file_name attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
iRet = H5Tclose(aid1);
|
|
iRet = H5Sclose(aid2);
|
|
iRet = H5Aclose(attr1);
|
|
/*----------- file time */
|
|
time_buffer = NXIformatNeXusTime();
|
|
if (time_buffer != NULL) {
|
|
aid2 = H5Screate(H5S_SCALAR);
|
|
aid1 = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(aid1, strlen(time_buffer));
|
|
attr1 = H5Acreate(iVID, "file_time", aid1, aid2, H5P_DEFAULT);
|
|
if (attr1 < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store file_time attribute ");
|
|
free(time_buffer);
|
|
return NX_ERROR;
|
|
}
|
|
if (H5Awrite(attr1, aid1, time_buffer) < 0) {
|
|
NXIReportError(NXpData,
|
|
"ERROR: HDF failed to store file_time attribute ");
|
|
free(time_buffer);
|
|
return NX_ERROR;
|
|
}
|
|
/* Close attribute dataspace */
|
|
iRet = H5Tclose(aid1);
|
|
iRet = H5Sclose(aid2);
|
|
/* Close attribute */
|
|
iRet = H5Aclose(attr1);
|
|
free(time_buffer);
|
|
}
|
|
H5Gclose(iVID);
|
|
}
|
|
/* Set HDFgroup access mode */
|
|
if (am1 == H5F_ACC_RDONLY) {
|
|
strcpy(pNew->iAccess, "r");
|
|
} else {
|
|
strcpy(pNew->iAccess, "w");
|
|
}
|
|
pNew->iNXID = NX5SIGNATURE;
|
|
pNew->iStack5[0].iVref = 0; /* root! */
|
|
*pHandle = (NXhandle) pNew;
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5close(NXhandle * fid)
|
|
{
|
|
pNexusFile5 pFile = NULL;
|
|
int iRet;
|
|
|
|
pFile = NXI5assert(*fid);
|
|
|
|
iRet = 0;
|
|
/*
|
|
printf("HDF5 object count before close: %d\n",
|
|
H5Fget_obj_count(pFile->iFID,H5F_OBJ_ALL));
|
|
*/
|
|
iRet = H5Fclose(pFile->iFID);
|
|
|
|
/*
|
|
leave this here: it helps in debugging leakage problems
|
|
printf("HDF5 object count after close: %d\n",
|
|
H5Fget_obj_count(H5F_OBJ_ALL,H5F_OBJ_ALL));
|
|
printf("HDF5 dataset count after close: %d\n",
|
|
H5Fget_obj_count(H5F_OBJ_ALL,H5F_OBJ_DATASET));
|
|
printf("HDF5 group count after close: %d\n",
|
|
H5Fget_obj_count(H5F_OBJ_ALL,H5F_OBJ_GROUP));
|
|
printf("HDF5 datatype count after close: %d\n",
|
|
H5Fget_obj_count(H5F_OBJ_ALL,H5F_OBJ_DATATYPE));
|
|
printf("HDF5 attribute count after close: %d\n",
|
|
H5Fget_obj_count(H5F_OBJ_ALL,H5F_OBJ_ATTR));
|
|
*/
|
|
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: HDF cannot close HDF file");
|
|
}
|
|
/* release memory */
|
|
NXI5KillDir(pFile);
|
|
if (pFile->iCurrentLGG != NULL) {
|
|
free(pFile->iCurrentLGG);
|
|
}
|
|
if (pFile->iCurrentLD != NULL) {
|
|
free(pFile->iCurrentLD);
|
|
}
|
|
free(pFile);
|
|
*fid = NULL;
|
|
H5garbage_collect();
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5makegroup(NXhandle fid, CONSTCHAR * name, CONSTCHAR * nxclass)
|
|
{
|
|
pNexusFile5 pFile;
|
|
hid_t iRet, iVID;
|
|
hid_t attr1, aid1, aid2;
|
|
char pBuffer[1024] = "";
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* create and configure the group */
|
|
if (pFile->iCurrentG == 0) {
|
|
iRet = H5Gcreate(pFile->iFID, (const char *) name, 0);
|
|
snprintf(pBuffer, 1023, "/%s", name);
|
|
} else {
|
|
snprintf(pBuffer, 1023, "/%s/%s", pFile->name_ref, name);
|
|
iRet = H5Gcreate(pFile->iFID, (const char *) pBuffer, 0);
|
|
}
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: HDF could not create Group");
|
|
return NX_ERROR;
|
|
}
|
|
iVID = iRet;
|
|
strncpy(pFile->name_ref, pBuffer, 1023);
|
|
aid2 = H5Screate(H5S_SCALAR);
|
|
aid1 = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(aid1, strlen(nxclass));
|
|
attr1 = H5Acreate(iVID, "NX_class", aid1, aid2, H5P_DEFAULT);
|
|
if (attr1 < 0) {
|
|
NXIReportError(NXpData, "ERROR: HDF failed to store class name!");
|
|
return NX_ERROR;
|
|
}
|
|
if (H5Awrite(attr1, aid1, (char *) nxclass) < 0) {
|
|
NXIReportError(NXpData, "ERROR: HDF failed to store class name!");
|
|
return NX_ERROR;
|
|
}
|
|
/* close group */
|
|
iRet = H5Sclose(aid2);
|
|
iRet = H5Tclose(aid1);
|
|
iRet = H5Aclose(attr1);
|
|
iRet = H5Gclose(iVID);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
herr_t attr_check(hid_t loc_id, const char *member_name, void *opdata)
|
|
{
|
|
char attr_name[8 + 1]; /* need to leave space for \0 as well */
|
|
|
|
strcpy(attr_name, "NX_class");
|
|
return strstr(member_name, attr_name) ? 1 : 0;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
NXstatus NX5opengroup(NXhandle fid, CONSTCHAR * name, CONSTCHAR * nxclass)
|
|
{
|
|
|
|
pNexusFile5 pFile;
|
|
hid_t iRet, attr1, atype;
|
|
char pBuffer[1024];
|
|
char data[128];
|
|
|
|
pFile = NXI5assert(fid);
|
|
if (pFile->iCurrentG == 0) {
|
|
strcpy(pBuffer, name);
|
|
} else {
|
|
sprintf(pBuffer, "%s/%s", pFile->name_tmp, name);
|
|
}
|
|
iRet = H5Gopen(pFile->iFID, (const char *) pBuffer);
|
|
if (iRet < 0) {
|
|
sprintf(pBuffer, "ERROR: Group %s does not exist!", pFile->name_tmp);
|
|
NXIReportError(NXpData, pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
pFile->iCurrentG = iRet;
|
|
strcpy(pFile->name_tmp, pBuffer);
|
|
strcpy(pFile->name_ref, pBuffer);
|
|
|
|
if ((nxclass != NULL) && (strcmp(nxclass, NX_UNKNOWN_GROUP) != 0)) {
|
|
/* check group attribute */
|
|
iRet = H5Aiterate(pFile->iCurrentG, NULL, attr_check, NULL);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR iterating through group!");
|
|
return NX_ERROR;
|
|
} else if (iRet == 1) {
|
|
/* group attribute was found */
|
|
} else {
|
|
/* no group attribute available */
|
|
NXIReportError(NXpData, "No group attribute available");
|
|
return NX_ERROR;
|
|
}
|
|
/* check contents of group attribute */
|
|
attr1 = H5Aopen_name(pFile->iCurrentG, "NX_class");
|
|
if (attr1 < 0) {
|
|
NXIReportError(NXpData, "Error opening NX_class group attribute!");
|
|
return NX_ERROR;
|
|
}
|
|
atype = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(atype, 128);
|
|
iRet = H5Aread(attr1, atype, data);
|
|
if (strcmp(data, nxclass) == 0) {
|
|
/* test OK */
|
|
} else {
|
|
NXIReportError(NXpData, "Group class is not identical!");
|
|
iRet = H5Tclose(atype);
|
|
iRet = H5Aclose(attr1);
|
|
return NX_ERROR;
|
|
}
|
|
iRet = H5Tclose(atype);
|
|
iRet = H5Aclose(attr1);
|
|
}
|
|
|
|
/* maintain stack */
|
|
pFile->iStackPtr++;
|
|
pFile->iStack5[pFile->iStackPtr].iVref = pFile->iCurrentG;
|
|
strcpy(pFile->iStack5[pFile->iStackPtr].irefn, name);
|
|
pFile->iAtt5.iCurrentIDX = 0;
|
|
pFile->iCurrentD = 0;
|
|
if (pFile->iCurrentLGG != NULL) {
|
|
free(pFile->iCurrentLGG);
|
|
}
|
|
pFile->iCurrentLGG = strdup(name);
|
|
NXI5KillDir(pFile);
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5closegroup(NXhandle fid)
|
|
{
|
|
pNexusFile5 pFile;
|
|
int i, ii;
|
|
char *uname = NULL;
|
|
char *u1name = NULL;
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* first catch the trivial case: we are at root and cannot get
|
|
deeper into a negative directory hierarchy (anti-directory)
|
|
*/
|
|
if (pFile->iCurrentG == 0) {
|
|
NXI5KillDir(pFile);
|
|
return NX_OK;
|
|
} else {
|
|
/* close the current group and decrement name_ref */
|
|
H5Gclose(pFile->iCurrentG);
|
|
i = 0;
|
|
i = strlen(pFile->iStack5[pFile->iStackPtr].irefn);
|
|
ii = strlen(pFile->name_ref);
|
|
if (pFile->iStackPtr > 1) {
|
|
ii = ii - i - 1;
|
|
} else {
|
|
ii = ii - i;
|
|
}
|
|
if (ii > 0) {
|
|
uname = strdup(pFile->name_ref);
|
|
u1name = (char *) malloc((ii + 1) * sizeof(char));
|
|
memset(u1name, 0, ii);
|
|
for (i = 0; i < ii; i++) {
|
|
*(u1name + i) = *(uname + i);
|
|
}
|
|
*(u1name + i) = '\0';
|
|
/*
|
|
strncpy(u1name, uname, ii);
|
|
*/
|
|
strcpy(pFile->name_ref, u1name);
|
|
strcpy(pFile->name_tmp, u1name);
|
|
free(uname);
|
|
free(u1name);
|
|
} else {
|
|
strcpy(pFile->name_ref, "");
|
|
strcpy(pFile->name_tmp, "");
|
|
}
|
|
NXI5KillDir(pFile);
|
|
pFile->iStackPtr--;
|
|
if (pFile->iStackPtr > 0) {
|
|
pFile->iCurrentG = pFile->iStack5[pFile->iStackPtr].iVref;
|
|
} else {
|
|
pFile->iCurrentG = 0;
|
|
}
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
static int nxToHDF5Type(int datatype)
|
|
{
|
|
int type;
|
|
if (datatype == NX_CHAR) {
|
|
type = H5T_C_S1;
|
|
} else if (datatype == NX_INT8) {
|
|
type = H5T_NATIVE_CHAR;
|
|
} else if (datatype == NX_UINT8) {
|
|
type = H5T_NATIVE_UCHAR;
|
|
} else if (datatype == NX_INT16) {
|
|
type = H5T_NATIVE_SHORT;
|
|
} else if (datatype == NX_UINT16) {
|
|
type = H5T_NATIVE_USHORT;
|
|
} else if (datatype == NX_INT32) {
|
|
type = H5T_NATIVE_INT;
|
|
} else if (datatype == NX_UINT32) {
|
|
type = H5T_NATIVE_UINT;
|
|
} else if (datatype == NX_INT64) {
|
|
type = H5T_NATIVE_INT64;
|
|
} else if (datatype == NX_UINT64) {
|
|
type = H5T_NATIVE_UINT64;
|
|
} else if (datatype == NX_FLOAT32) {
|
|
type = H5T_NATIVE_FLOAT;
|
|
} else if (datatype == NX_FLOAT64) {
|
|
type = H5T_NATIVE_DOUBLE;
|
|
} else {
|
|
NXIReportError(NXpData, "ERROR: nxToHDF5Type: unknown type");
|
|
type = -1;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5compmakedata(NXhandle fid, CONSTCHAR * name,
|
|
int datatype,
|
|
int rank, int dimensions[],
|
|
int compress_type, int chunk_size[])
|
|
{
|
|
hid_t datatype1, dataspace, iNew, iRet;
|
|
hid_t type, cparms = -1;
|
|
pNexusFile5 pFile;
|
|
char pBuffer[256];
|
|
int i, byte_zahl = 0;
|
|
hsize_t chunkdims[H5S_MAX_RANK];
|
|
hsize_t mydim[H5S_MAX_RANK], mydim1[H5S_MAX_RANK];
|
|
hsize_t size[H5S_MAX_RANK];
|
|
hsize_t maxdims[H5S_MAX_RANK];
|
|
|
|
pFile = NXI5assert(fid);
|
|
|
|
for (i = 0; i < rank; i++) {
|
|
chunkdims[i] = chunk_size[i];
|
|
mydim[i] = dimensions[i];
|
|
maxdims[i] = dimensions[i];
|
|
size[i] = dimensions[i];
|
|
}
|
|
|
|
type = nxToHDF5Type(datatype);
|
|
|
|
if (rank <= 0) {
|
|
sprintf(pBuffer, "ERROR: invalid rank specified %s", name);
|
|
NXIReportError(NXpData, pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
/*
|
|
Check dimensions for consistency. The first dimension may be -1
|
|
thus denoting an unlimited dimension.
|
|
*/
|
|
for (i = 1; i < rank; i++) {
|
|
if (dimensions[i] <= 0) {
|
|
sprintf(pBuffer,
|
|
"ERROR: invalid dimension %d, value %d given for Dataset %s",
|
|
i, dimensions[i], name);
|
|
NXIReportError(NXpData, pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
if (datatype == NX_CHAR) {
|
|
/*
|
|
* This assumes string lenght is in the last dimensions and
|
|
* the logic must be the same as used in NX5getslab and NX5getinfo
|
|
*
|
|
* search for tests on H5T_STRING
|
|
*/
|
|
byte_zahl = dimensions[rank - 1];
|
|
for (i = 0; i < rank; i++) {
|
|
mydim1[i] = dimensions[i];
|
|
}
|
|
mydim1[rank - 1] = 1;
|
|
if (dimensions[rank - 1] > 1) {
|
|
mydim[rank - 1] = maxdims[rank - 1] = size[rank - 1] = 1;
|
|
}
|
|
if (chunkdims[rank - 1] > 1) {
|
|
chunkdims[rank - 1] = 1;
|
|
}
|
|
if (dimensions[0] == NX_UNLIMITED) {
|
|
mydim1[0] = 1;
|
|
maxdims[0] = H5S_UNLIMITED;
|
|
}
|
|
dataspace = H5Screate_simple(rank, mydim1, maxdims);
|
|
} else {
|
|
if (dimensions[0] == NX_UNLIMITED) {
|
|
mydim[0] = 1;
|
|
maxdims[0] = H5S_UNLIMITED;
|
|
dataspace = H5Screate_simple(rank, mydim, maxdims);
|
|
} else {
|
|
/* dataset creation */
|
|
dataspace = H5Screate_simple(rank, mydim, NULL);
|
|
}
|
|
}
|
|
datatype1 = H5Tcopy(type);
|
|
if (datatype == NX_CHAR) {
|
|
H5Tset_size(datatype1, byte_zahl);
|
|
/* H5Tset_strpad(H5T_STR_SPACEPAD); */
|
|
}
|
|
if (compress_type == NX_COMP_LZW) {
|
|
cparms = H5Pcreate(H5P_DATASET_CREATE);
|
|
iNew = H5Pset_chunk(cparms, rank, chunkdims);
|
|
if (iNew < 0) {
|
|
NXIReportError(NXpData, "ERROR: Size of chunks could not be set!");
|
|
return NX_ERROR;
|
|
}
|
|
H5Pset_deflate(cparms, 6);
|
|
iRet = H5Dcreate(pFile->iCurrentG, (char *) name, datatype1,
|
|
dataspace, cparms);
|
|
} else if (compress_type == NX_COMP_NONE) {
|
|
if (dimensions[0] == NX_UNLIMITED) {
|
|
cparms = H5Pcreate(H5P_DATASET_CREATE);
|
|
iNew = H5Pset_chunk(cparms, rank, chunkdims);
|
|
if (iNew < 0) {
|
|
NXIReportError(NXpData, "ERROR: Size of chunks could not be set!");
|
|
return NX_ERROR;
|
|
}
|
|
iRet = H5Dcreate(pFile->iCurrentG, (char *) name, datatype1,
|
|
dataspace, cparms);
|
|
} else {
|
|
iRet = H5Dcreate(pFile->iCurrentG, (char *) name, datatype1,
|
|
dataspace, H5P_DEFAULT);
|
|
}
|
|
} else {
|
|
NXIReportError(NXpData,
|
|
"HDF5 doesn't support selected compression method! Dataset was saved without compression");
|
|
iRet = H5Dcreate(pFile->iCurrentG, (char *) name, datatype1,
|
|
dataspace, H5P_DEFAULT);
|
|
}
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: Creating chunked dataset failed!");
|
|
return NX_ERROR;
|
|
} else {
|
|
pFile->iCurrentD = iRet;
|
|
}
|
|
if (dimensions[0] == NX_UNLIMITED) {
|
|
size[0] = 1;
|
|
iNew = H5Dextend(pFile->iCurrentD, size);
|
|
if (iNew < 0) {
|
|
sprintf(pBuffer, "ERROR: cannot create Dataset %s, check arguments",
|
|
name);
|
|
NXIReportError(NXpData, pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
if (cparms != -1) {
|
|
iRet = H5Pclose(cparms);
|
|
}
|
|
iRet = H5Sclose(dataspace);
|
|
iRet = H5Tclose(datatype1);
|
|
iRet = H5Dclose(pFile->iCurrentD);
|
|
pFile->iCurrentD = 0;
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: HDF cannot close Dataset");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5makedata(NXhandle fid, CONSTCHAR * name, int datatype,
|
|
int rank, int dimensions[])
|
|
{
|
|
pNexusFile5 pFile;
|
|
int chunk_size[H5S_MAX_RANK];
|
|
int i;
|
|
|
|
pFile = NXI5assert(fid);
|
|
memset(chunk_size, 0, H5S_MAX_RANK * sizeof(int));
|
|
if (dimensions[0] == NX_UNLIMITED) {
|
|
for (i = 0; i < H5S_MAX_RANK; i++) {
|
|
chunk_size[i] = 1;
|
|
}
|
|
}
|
|
return NX5compmakedata(fid, name, datatype, rank, dimensions,
|
|
NX_COMP_NONE, chunk_size);
|
|
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5compress(NXhandle fid, int compress_type)
|
|
{
|
|
printf
|
|
(" NXcompress ERROR: NeXus API based on HDF5 doesn't support\n");
|
|
printf
|
|
(" NXcompress function! Using HDF5 library,\n");
|
|
printf
|
|
(" the NXcompmakedata function can be applied\n");
|
|
printf(" for compression of data!\n");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5opendata(NXhandle fid, CONSTCHAR * name)
|
|
{
|
|
pNexusFile5 pFile;
|
|
char pBuffer[256];
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* clear pending attribute directories first */
|
|
NXI5KillAttDir(pFile);
|
|
|
|
|
|
/* find the ID number and open the dataset */
|
|
pFile->iCurrentD = H5Dopen(pFile->iCurrentG, name);
|
|
if (pFile->iCurrentD < 0) {
|
|
sprintf(pBuffer, "ERROR: Dataset %s not found at this level", name);
|
|
NXIReportError(NXpData, pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
/* find the ID number of datatype */
|
|
pFile->iCurrentT = H5Dget_type(pFile->iCurrentD);
|
|
if (pFile->iCurrentT < 0) {
|
|
NXIReportError(NXpData, "ERROR:HDF error opening Dataset");
|
|
pFile->iCurrentT = 0;
|
|
return NX_ERROR;
|
|
}
|
|
/* find the ID number of dataspace */
|
|
pFile->iCurrentS = H5Dget_space(pFile->iCurrentD);
|
|
if (pFile->iCurrentS < 0) {
|
|
NXIReportError(NXpData, "ERROR:HDF error opening Dataset");
|
|
pFile->iCurrentS = 0;
|
|
return NX_ERROR;
|
|
}
|
|
if (pFile->iCurrentLD != NULL) {
|
|
free(pFile->iCurrentLD);
|
|
}
|
|
pFile->iCurrentLD = strdup(name);
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------- */
|
|
|
|
NXstatus NX5closedata(NXhandle fid)
|
|
{
|
|
pNexusFile5 pFile;
|
|
int iRet;
|
|
|
|
pFile = NXI5assert(fid);
|
|
iRet = H5Sclose(pFile->iCurrentS);
|
|
iRet = H5Tclose(pFile->iCurrentT);
|
|
iRet = H5Dclose(pFile->iCurrentD);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: HDF cannot end access to Dataset");
|
|
return NX_ERROR;
|
|
}
|
|
pFile->iCurrentD = 0;
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
NXstatus NX5putdata(NXhandle fid, void *data)
|
|
{
|
|
pNexusFile5 pFile;
|
|
hid_t iRet;
|
|
|
|
char pError[512] = "";
|
|
|
|
pFile = NXI5assert(fid);
|
|
|
|
/* actually write */
|
|
iRet = H5Dwrite(pFile->iCurrentD, pFile->iCurrentT, H5S_ALL, H5S_ALL,
|
|
H5P_DEFAULT, data);
|
|
if (iRet < 0) {
|
|
snprintf(pError, 511, "ERROR: failure to write data");
|
|
NXIReportError(NXpData, pError);
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*------------------------------------------------------------------*/
|
|
static int getAttVID(pNexusFile5 pFile)
|
|
{
|
|
int vid;
|
|
if (pFile->iCurrentG == 0 && pFile->iCurrentD == 0) {
|
|
/* global attribute */
|
|
vid = H5Gopen(pFile->iFID, "/");
|
|
} else if (pFile->iCurrentD != 0) {
|
|
/* dataset attribute */
|
|
vid = pFile->iCurrentD;
|
|
} else {
|
|
/* group attribute */ ;
|
|
vid = pFile->iCurrentG;
|
|
}
|
|
return vid;
|
|
}
|
|
|
|
/*---------------------------------------------------------------*/
|
|
static void killAttVID(pNexusFile5 pFile, int vid)
|
|
{
|
|
if (pFile->iCurrentG == 0 && pFile->iCurrentD == 0) {
|
|
H5Gclose(vid);
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5putattr(NXhandle fid, CONSTCHAR * name, void *data,
|
|
int datalen, int iType)
|
|
{
|
|
pNexusFile5 pFile;
|
|
hid_t attr1, aid1, aid2;
|
|
hid_t type;
|
|
int iRet;
|
|
int vid;
|
|
|
|
pFile = NXI5assert(fid);
|
|
|
|
type = nxToHDF5Type(iType);
|
|
|
|
/* determine vid */
|
|
vid = getAttVID(pFile);
|
|
aid2 = H5Screate(H5S_SCALAR);
|
|
aid1 = H5Tcopy(type);
|
|
if (iType == NX_CHAR) {
|
|
H5Tset_size(aid1, datalen);
|
|
}
|
|
iRet = H5Aopen_name(vid, name);
|
|
if (iRet > 0) {
|
|
H5Aclose(iRet);
|
|
iRet = H5Adelete(vid, name);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: Old attribute cannot removed! ");
|
|
killAttVID(pFile, vid);
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
attr1 = H5Acreate(vid, name, aid1, aid2, H5P_DEFAULT);
|
|
if (attr1 < 0) {
|
|
NXIReportError(NXpData, "ERROR: Attribute cannot created! ");
|
|
killAttVID(pFile, vid);
|
|
return NX_ERROR;
|
|
}
|
|
if (H5Awrite(attr1, aid1, data) < 0) {
|
|
NXIReportError(NXpData, "ERROR: HDF failed to store attribute ");
|
|
killAttVID(pFile, vid);
|
|
return NX_ERROR;
|
|
}
|
|
/* Close attribute dataspace */
|
|
iRet = H5Tclose(aid1);
|
|
iRet = H5Sclose(aid2);
|
|
/* Close attribute */
|
|
iRet = H5Aclose(attr1);
|
|
killAttVID(pFile, vid);
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5putslab(NXhandle fid, void *data, int iStart[], int iSize[])
|
|
{
|
|
pNexusFile5 pFile;
|
|
int iRet, i;
|
|
int rank;
|
|
hsize_t myStart[H5S_MAX_RANK];
|
|
hsize_t mySize[H5S_MAX_RANK];
|
|
hsize_t size[H5S_MAX_RANK], maxdims[H5S_MAX_RANK];
|
|
hid_t filespace, dataspace;
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* check if there is an Dataset open */
|
|
if (pFile->iCurrentD == 0) {
|
|
NXIReportError(NXpData, "ERROR: no dataset open");
|
|
return NX_ERROR;
|
|
}
|
|
rank = H5Sget_simple_extent_ndims(pFile->iCurrentS);
|
|
iRet = H5Sget_simple_extent_dims(pFile->iCurrentS, NULL, maxdims);
|
|
for (i = 0; i < rank; i++) {
|
|
myStart[i] = iStart[i];
|
|
mySize[i] = iSize[i];
|
|
size[i] = iSize[i];
|
|
}
|
|
if (H5Tget_class(pFile->iCurrentT) == H5T_STRING) {
|
|
mySize[rank - 1] = 1;
|
|
myStart[rank - 1] = 0;
|
|
}
|
|
dataspace = H5Screate_simple(rank, mySize, NULL);
|
|
if (maxdims[0] == NX_UNLIMITED) {
|
|
size[0] = iStart[0] + iSize[0];
|
|
iRet = H5Dextend(pFile->iCurrentD, size);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: extend slab failed");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
filespace = H5Dget_space(pFile->iCurrentD);
|
|
|
|
/* define slab */
|
|
iRet = H5Sselect_hyperslab(filespace, H5S_SELECT_SET, myStart,
|
|
NULL, mySize, NULL);
|
|
/* deal with HDF errors */
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: selecting slab failed");
|
|
return NX_ERROR;
|
|
}
|
|
/* write slab */
|
|
iRet = H5Dwrite(pFile->iCurrentD, pFile->iCurrentT, dataspace,
|
|
filespace, H5P_DEFAULT, data);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: writing slab failed");
|
|
}
|
|
iRet = H5Sclose(filespace);
|
|
} else {
|
|
/* define slab */
|
|
iRet = H5Sselect_hyperslab(pFile->iCurrentS, H5S_SELECT_SET, myStart,
|
|
NULL, mySize, NULL);
|
|
/* deal with HDF errors */
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: selecting slab failed");
|
|
return NX_ERROR;
|
|
}
|
|
/* write slab */
|
|
iRet = H5Dwrite(pFile->iCurrentD, pFile->iCurrentT, dataspace,
|
|
pFile->iCurrentS, H5P_DEFAULT, data);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: writing slab failed");
|
|
}
|
|
}
|
|
/* deal with HDF errors */
|
|
iRet = H5Sclose(dataspace);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: closing slab failed");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5getdataID(NXhandle fid, NXlink * sRes)
|
|
{
|
|
pNexusFile5 pFile;
|
|
ErrFunc oldErr;
|
|
int datalen, type = NX_CHAR;
|
|
|
|
pFile = NXI5assert(fid);
|
|
|
|
/*
|
|
we cannot return ID's when no datset is open
|
|
*/
|
|
if (pFile->iCurrentD <= 0) {
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/*
|
|
this means: if the item is already linked: use the target attribute else,
|
|
the path to the current node
|
|
*/
|
|
oldErr = NXMGetError();
|
|
NXMSetError(NXpData, ignoreError);
|
|
datalen = 1024;
|
|
memset(&sRes->targetPath, 0, datalen * sizeof(char));
|
|
if (NX5getattr(fid, "target", &sRes->targetPath, &datalen, &type) !=
|
|
NX_OK) {
|
|
buildCurrentPath(pFile, sRes->targetPath, 1024);
|
|
}
|
|
NXMSetError(NXpData, oldErr);
|
|
sRes->linkType = 1;
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5printlink(NXhandle fid, NXlink * sLink)
|
|
{
|
|
pNexusFile5 pFile;
|
|
pFile = NXI5assert(fid);
|
|
printf("HDF5 link: targetPath = \"%s\", linkType = \"%d\"\n",
|
|
sLink->targetPath, sLink->linkType);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
static NXstatus NX5settargetattribute(pNexusFile5 pFile, NXlink * sLink)
|
|
{
|
|
herr_t length, dataID, status, aid2, aid1, attID;
|
|
int type = NX_CHAR;
|
|
char name[] = "target";
|
|
|
|
length = strlen(sLink->targetPath);
|
|
/*
|
|
set the target attribute
|
|
*/
|
|
if (sLink->linkType > 0) {
|
|
dataID = H5Dopen(pFile->iFID, sLink->targetPath);
|
|
} else {
|
|
dataID = H5Gopen(pFile->iFID, sLink->targetPath);
|
|
}
|
|
if (dataID < 0) {
|
|
NXIReportError(NXpData, "Internal error, path to link does not exist");
|
|
return NX_ERROR;
|
|
}
|
|
status = H5Aopen_name(dataID, name);
|
|
if (status > 0) {
|
|
H5Aclose(status);
|
|
status = H5Adelete(dataID, name);
|
|
if (status < 0) {
|
|
return NX_OK;
|
|
}
|
|
}
|
|
aid2 = H5Screate(H5S_SCALAR);
|
|
aid1 = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(aid1, strlen(sLink->targetPath));
|
|
attID = H5Acreate(dataID, name, aid1, aid2, H5P_DEFAULT);
|
|
if (attID < 0) {
|
|
return NX_OK;
|
|
}
|
|
status = H5Awrite(attID, aid1, sLink->targetPath);
|
|
H5Tclose(aid1);
|
|
H5Sclose(aid2);
|
|
H5Aclose(attID);
|
|
if (sLink->linkType > 0) {
|
|
H5Dclose(dataID);
|
|
} else {
|
|
H5Gclose(dataID);
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*---------------------------------------------------------------------*/
|
|
NXstatus NX5makenamedlink(NXhandle fid, CONSTCHAR * name, NXlink * sLink)
|
|
{
|
|
pNexusFile5 pFile;
|
|
char linkTarget[1024];
|
|
int type = NX_CHAR, length;
|
|
int status;
|
|
|
|
pFile = NXI5assert(fid);
|
|
if (pFile->iCurrentG == 0) { /* root level, can not link here */
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/*
|
|
build pathname to link from our current group and the name
|
|
of the thing to link
|
|
*/
|
|
if (strlen(pFile->name_ref) + strlen(name) + 2 < 1024) {
|
|
strcpy(linkTarget, "/");
|
|
strcat(linkTarget, pFile->name_ref);
|
|
strcat(linkTarget, "/");
|
|
strcat(linkTarget, name);
|
|
} else {
|
|
NXIReportError(NXpData, "Path string to long");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
status =
|
|
H5Glink(pFile->iFID, H5G_LINK_HARD, sLink->targetPath, linkTarget);
|
|
|
|
return NX5settargetattribute(pFile, sLink);
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5makelink(NXhandle fid, NXlink * sLink)
|
|
{
|
|
pNexusFile5 pFile;
|
|
char linkTarget[1024];
|
|
int type = NX_CHAR, length;
|
|
char *itemName = NULL;
|
|
int status;
|
|
|
|
pFile = NXI5assert(fid);
|
|
if (pFile->iCurrentG == 0) { /* root level, can not link here */
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/*
|
|
locate name of the element to link
|
|
*/
|
|
itemName = strrchr(sLink->targetPath, '/');
|
|
if (itemName == NULL) {
|
|
NXIReportError(NXpData, "Bad link structure");
|
|
return NX_ERROR;
|
|
}
|
|
itemName++;
|
|
|
|
/*
|
|
build pathname to link from our current group and the name
|
|
of the thing to link
|
|
*/
|
|
if (strlen(pFile->name_ref) + strlen(itemName) + 2 < 1024) {
|
|
strcpy(linkTarget, "/");
|
|
strcat(linkTarget, pFile->name_ref);
|
|
strcat(linkTarget, "/");
|
|
strcat(linkTarget, itemName);
|
|
} else {
|
|
NXIReportError(NXpData, "Path string to long");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
status =
|
|
H5Glink(pFile->iFID, H5G_LINK_HARD, sLink->targetPath, linkTarget);
|
|
|
|
return NX5settargetattribute(pFile, sLink);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5flush(NXhandle * pHandle)
|
|
{
|
|
pNexusFile5 pFile = NULL;
|
|
int iRet;
|
|
|
|
pFile = NXI5assert(*pHandle);
|
|
if (pFile->iCurrentD != 0) {
|
|
iRet = H5Fflush(pFile->iCurrentD, H5F_SCOPE_LOCAL);
|
|
} else if (pFile->iCurrentG != 0) {
|
|
iRet = H5Fflush(pFile->iCurrentG, H5F_SCOPE_LOCAL);
|
|
} else {
|
|
iRet = H5Fflush(pFile->iFID, H5F_SCOPE_LOCAL);
|
|
}
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: The object cannot be flushed");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
/* Operator function. */
|
|
|
|
herr_t nxgroup_info(hid_t loc_id, const char *name, void *op_data)
|
|
{
|
|
H5G_stat_t statbuf;
|
|
pinfo self;
|
|
|
|
self = (pinfo) op_data;
|
|
H5Gget_objinfo(loc_id, name, 0, &statbuf);
|
|
switch (statbuf.type) {
|
|
case H5G_GROUP:
|
|
self->iname = strdup(name);
|
|
self->type = H5G_GROUP;
|
|
break;
|
|
case H5G_DATASET:
|
|
self->iname = strdup(name);
|
|
self->type = H5G_DATASET;
|
|
break;
|
|
default:
|
|
self->type = 0;
|
|
break;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
/* Operator function. */
|
|
|
|
herr_t group_info1(hid_t loc_id, const char *name, void *opdata)
|
|
{
|
|
NexusFile5 self;
|
|
H5G_stat_t statbuf;
|
|
self.iNX = *((int *) opdata);
|
|
H5Gget_objinfo(loc_id, name, 0, &statbuf);
|
|
|
|
switch (statbuf.type) {
|
|
case H5G_GROUP:
|
|
self.iNX++;
|
|
*((int *) opdata) = self.iNX;
|
|
break;
|
|
case H5G_DATASET:
|
|
self.iNX++;
|
|
*((int *) opdata) = self.iNX;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5getgroupinfo(NXhandle fid, int *iN, NXname pName,
|
|
NXname pClass)
|
|
{
|
|
pNexusFile5 pFile;
|
|
hid_t atype, attr_id;
|
|
char data[64];
|
|
int iRet;
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* check if there is a group open */
|
|
if (pFile->iCurrentG == 0) {
|
|
strcpy(pName, "root");
|
|
strcpy(pClass, "NXroot");
|
|
pFile->iNX = 0;
|
|
iRet = H5Giterate(pFile->iFID, "/", 0, group_info1, &pFile->iNX);
|
|
*iN = pFile->iNX;
|
|
} else {
|
|
strcpy(pName, pFile->name_ref);
|
|
attr_id = H5Aopen_name(pFile->iCurrentG, "NX_class");
|
|
if (attr_id < 0) {
|
|
strcpy(pClass, NX_UNKNOWN_GROUP);
|
|
} else {
|
|
atype = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(atype, 64);
|
|
H5Aread(attr_id, atype, data);
|
|
strcpy(pClass, data);
|
|
pFile->iNX = 0;
|
|
iRet =
|
|
H5Giterate(pFile->iFID, pFile->name_ref, 0, group_info1,
|
|
&pFile->iNX);
|
|
*iN = pFile->iNX;
|
|
H5Aclose(attr_id);
|
|
}
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
static int hdf5ToNXType(int data_id, hid_t atype)
|
|
{
|
|
int iPtype = -1;
|
|
hid_t sign_id, size_id;
|
|
|
|
if (data_id == H5T_STRING) {
|
|
iPtype = NX_CHAR;
|
|
}
|
|
if (data_id == H5T_INTEGER) {
|
|
size_id = H5Tget_size(atype);
|
|
sign_id = H5Tget_sign(atype);
|
|
if (size_id == 1) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
iPtype = NX_INT8;
|
|
} else {
|
|
iPtype = NX_UINT8;
|
|
}
|
|
} else if (size_id == 2) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
iPtype = NX_INT16;
|
|
} else {
|
|
iPtype = NX_UINT16;
|
|
}
|
|
} else if (size_id == 4) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
iPtype = NX_INT32;
|
|
} else {
|
|
iPtype = NX_UINT32;
|
|
}
|
|
} else if (size_id == 8) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
iPtype = NX_INT64;
|
|
} else {
|
|
iPtype = NX_UINT64;
|
|
}
|
|
}
|
|
} else if (data_id == H5T_FLOAT) {
|
|
size_id = H5Tget_size(atype);
|
|
if (size_id == 4) {
|
|
iPtype = NX_FLOAT32;
|
|
} else if (size_id == 8) {
|
|
iPtype = NX_FLOAT64;
|
|
}
|
|
}
|
|
if (iPtype == -1) {
|
|
NXIReportError(NXpData, "ERROR: hdf5ToNXtype: invalid type");
|
|
}
|
|
|
|
return iPtype;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------*/
|
|
static int h5MemType(hid_t atype)
|
|
{
|
|
hid_t data_id, size_id, sign_id, memtype_id = -1;
|
|
|
|
data_id = H5Tget_class(atype);
|
|
|
|
if (data_id == H5T_INTEGER) {
|
|
size_id = H5Tget_size(atype);
|
|
sign_id = H5Tget_sign(atype);
|
|
if (size_id == 1) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
memtype_id = H5T_NATIVE_INT8;
|
|
} else {
|
|
memtype_id = H5T_NATIVE_UINT8;
|
|
}
|
|
} else if (size_id == 2) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
memtype_id = H5T_NATIVE_INT16;
|
|
} else {
|
|
memtype_id = H5T_NATIVE_UINT16;
|
|
}
|
|
} else if (size_id == 4) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
memtype_id = H5T_NATIVE_INT32;
|
|
} else {
|
|
memtype_id = H5T_NATIVE_UINT32;
|
|
}
|
|
} else if (size_id == 8) {
|
|
if (sign_id == H5T_SGN_2) {
|
|
memtype_id = H5T_NATIVE_INT64;
|
|
} else {
|
|
memtype_id = H5T_NATIVE_UINT64;
|
|
}
|
|
}
|
|
} else if (data_id == H5T_FLOAT) {
|
|
size_id = H5Tget_size(atype);
|
|
if (size_id == 4) {
|
|
memtype_id = H5T_NATIVE_FLOAT;
|
|
} else if (size_id == 8) {
|
|
memtype_id = H5T_NATIVE_DOUBLE;
|
|
}
|
|
}
|
|
if (memtype_id == -1) {
|
|
NXIReportError(NXpData, "ERROR: h5MemType: invalid type");
|
|
}
|
|
return memtype_id;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5getnextentry(NXhandle fid, NXname name, NXname nxclass,
|
|
int *datatype)
|
|
{
|
|
pNexusFile5 pFile;
|
|
hid_t grp, attr1, type, atype;
|
|
int iRet, iPtype, i;
|
|
int idx, data_id, size_id, sign_id;
|
|
char data[128];
|
|
char ph_name[1024];
|
|
info_type op_data;
|
|
int iRet_iNX = -1;
|
|
char pBuffer[256];
|
|
|
|
pFile = NXI5assert(fid);
|
|
op_data.iname = NULL;
|
|
|
|
/*
|
|
iterate to next entry in group list
|
|
*/
|
|
idx = pFile->iStack5[pFile->iStackPtr].iCurrentIDX;
|
|
if (strlen(pFile->name_ref) == 0) {
|
|
/* root group */
|
|
strcpy(pFile->name_ref, "/");
|
|
}
|
|
iRet =
|
|
H5Giterate(pFile->iFID, pFile->name_ref, &idx, nxgroup_info,
|
|
&op_data);
|
|
strcpy(nxclass, NX_UNKNOWN_GROUP);
|
|
|
|
/*
|
|
figure out the number of items in the current group. We need this in order to
|
|
find out if we are at the end of the search.
|
|
*/
|
|
if (pFile->iCurrentG == 0) {
|
|
pFile->iNX = 0;
|
|
iRet_iNX = H5Giterate(pFile->iFID, "/", 0, group_info1, &pFile->iNX);
|
|
} else {
|
|
pFile->iNX = 0;
|
|
iRet_iNX =
|
|
H5Giterate(pFile->iFID, pFile->name_ref, 0, group_info1,
|
|
&pFile->iNX);
|
|
}
|
|
if (idx == pFile->iNX) {
|
|
iRet_iNX = 2;
|
|
}
|
|
|
|
if (iRet > 0) {
|
|
pFile->iStack5[pFile->iStackPtr].iCurrentIDX++;
|
|
if (op_data.iname != NULL) {
|
|
strcpy(name, op_data.iname);
|
|
free(op_data.iname);
|
|
} else {
|
|
pFile->iStack5[pFile->iStackPtr].iCurrentIDX = 0;
|
|
return NX_EOD;
|
|
}
|
|
if (op_data.type == H5G_GROUP) {
|
|
/*
|
|
open group and find class name attribute
|
|
*/
|
|
strcpy(ph_name, "");
|
|
for (i = 1; i < (pFile->iStackPtr + 1); i++) {
|
|
strcat(ph_name, pFile->iStack5[i].irefn);
|
|
strcat(ph_name, "/");
|
|
}
|
|
strcat(ph_name, name);
|
|
grp = H5Gopen(pFile->iFID, ph_name);
|
|
if (grp < 0) {
|
|
sprintf(pBuffer, "ERROR: Group %s does not exist!", ph_name);
|
|
NXIReportError(NXpData, pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
attr1 = H5Aopen_name(grp, "NX_class");
|
|
if (attr1 < 0) {
|
|
strcpy(nxclass, NX_UNKNOWN_GROUP);
|
|
} else {
|
|
type = H5T_C_S1;
|
|
atype = H5Tcopy(type);
|
|
H5Tset_size(atype, 128);
|
|
iRet = H5Aread(attr1, atype, data);
|
|
strcpy(nxclass, data);
|
|
H5Tclose(atype);
|
|
H5Aclose(attr1);
|
|
}
|
|
H5Gclose(grp);
|
|
} else if (op_data.type == H5G_DATASET) {
|
|
/*
|
|
open dataset and find type
|
|
*/
|
|
grp = H5Dopen(pFile->iCurrentG, name);
|
|
type = H5Dget_type(grp);
|
|
atype = H5Tcopy(type);
|
|
data_id = H5Tget_class(atype);
|
|
iPtype = hdf5ToNXType(data_id, atype);
|
|
*datatype = iPtype;
|
|
strcpy(nxclass, "SDS");
|
|
H5Tclose(atype);
|
|
H5Tclose(type);
|
|
H5Dclose(grp);
|
|
}
|
|
return NX_OK;
|
|
} else {
|
|
/*
|
|
we are at the end of the search: clear the data structure and reset
|
|
iCurrentIDX to 0
|
|
*/
|
|
if (iRet_iNX == 2) {
|
|
if (op_data.iname != NULL) {
|
|
free(op_data.iname);
|
|
}
|
|
pFile->iStack5[pFile->iStackPtr].iCurrentIDX = 0;
|
|
return NX_EOD;
|
|
}
|
|
if (op_data.iname != NULL) {
|
|
free(op_data.iname);
|
|
}
|
|
NXIReportError(NXpData,
|
|
"ERROR: Iteration (directory) was not successful");
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5getdata(NXhandle fid, void *data)
|
|
{
|
|
pNexusFile5 pFile;
|
|
int iStart[H5S_MAX_RANK], status;
|
|
hid_t data_id, memtype_id, size_id, sign_id;
|
|
int dims;
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* check if there is an Dataset open */
|
|
if (pFile->iCurrentD == 0) {
|
|
NXIReportError(NXpData, "ERROR: no Dataset open");
|
|
return NX_ERROR;
|
|
}
|
|
memset(iStart, 0, H5S_MAX_RANK * sizeof(int));
|
|
/* map datatypes of other plateforms */
|
|
data_id = H5Tget_class(pFile->iCurrentT);
|
|
if (data_id == H5T_STRING) {
|
|
dims = H5Tget_size(pFile->iCurrentT);
|
|
memtype_id = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(memtype_id, dims);
|
|
} else {
|
|
memtype_id = h5MemType(pFile->iCurrentT);
|
|
}
|
|
|
|
/* actually read */
|
|
status = H5Dread(pFile->iCurrentD, memtype_id,
|
|
H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
|
|
if (data_id == H5T_STRING) {
|
|
H5Tclose(memtype_id);
|
|
}
|
|
if (status < 0) {
|
|
NXIReportError(NXpData, "ERROR: failed to transfer dataset");
|
|
return NX_ERROR;
|
|
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5getinfo(NXhandle fid, int *rank, int dimension[], int *iType)
|
|
{
|
|
pNexusFile5 pFile;
|
|
int i, iRank, mType, iRet;
|
|
hsize_t myDim[H5S_MAX_RANK];
|
|
hid_t data_id, size_id, sign_id;
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* check if there is an Dataset open */
|
|
if (pFile->iCurrentD == 0) {
|
|
NXIReportError(NXpData, "ERROR: no Dataset open");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/* read information */
|
|
data_id = H5Tget_class(pFile->iCurrentT);
|
|
mType = hdf5ToNXType(data_id, pFile->iCurrentT);
|
|
iRank = H5Sget_simple_extent_ndims(pFile->iCurrentS);
|
|
iRet = H5Sget_simple_extent_dims(pFile->iCurrentS, myDim, NULL);
|
|
/* conversion to proper ints for the platform */
|
|
*iType = (int) mType;
|
|
if (data_id == H5T_STRING && myDim[iRank - 1] == 1) {
|
|
myDim[iRank - 1] = H5Tget_size(pFile->iCurrentT);
|
|
}
|
|
*rank = (int) iRank;
|
|
for (i = 0; i < iRank; i++) {
|
|
dimension[i] = (int) myDim[i];
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5getslab(NXhandle fid, void *data, int iStart[], int iSize[])
|
|
{
|
|
pNexusFile5 pFile;
|
|
hsize_t myStart[H5S_MAX_RANK];
|
|
hsize_t mySize[H5S_MAX_RANK];
|
|
hsize_t mStart[H5S_MAX_RANK];
|
|
hid_t memspace, iRet, data_id;
|
|
hid_t memtype_id, size_id, sign_id;
|
|
char *tmp_data = NULL;
|
|
char *data1;
|
|
int i, dims, iRank, mtype = 0;
|
|
|
|
pFile = NXI5assert(fid);
|
|
/* check if there is an Dataset open */
|
|
if (pFile->iCurrentD == 0) {
|
|
NXIReportError(NXpData, "ERROR: no Dataset open");
|
|
return NX_ERROR;
|
|
}
|
|
iRank = H5Sget_simple_extent_ndims(pFile->iCurrentS);
|
|
for (i = 0; i < iRank; i++) {
|
|
myStart[i] = (hssize_t) iStart[i];
|
|
mySize[i] = (hsize_t) iSize[i];
|
|
mStart[i] = (hsize_t) 0;
|
|
}
|
|
data_id = H5Tget_class(pFile->iCurrentT);
|
|
if (data_id == H5T_STRING) {
|
|
/*
|
|
* FAA 24/1/2007: I don't think this will work for multidimensional
|
|
* string arrays.
|
|
* MK 23/7/2007: You are right Freddie.
|
|
*/
|
|
mtype = NX_CHAR;
|
|
if (mySize[0] == 1) {
|
|
mySize[0] = H5Tget_size(pFile->iCurrentT);
|
|
}
|
|
tmp_data = (char *) malloc(mySize[0]);
|
|
memset(tmp_data, 0, sizeof(mySize[0]));
|
|
iRet = H5Sselect_hyperslab(pFile->iCurrentS, H5S_SELECT_SET, mStart,
|
|
NULL, mySize, NULL);
|
|
} else {
|
|
iRet = H5Sselect_hyperslab(pFile->iCurrentS, H5S_SELECT_SET, myStart,
|
|
NULL, mySize, NULL);
|
|
}
|
|
/* define slab */
|
|
/* deal with HDF errors */
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: selecting slab failed");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
memspace = H5Screate_simple(iRank, mySize, NULL);
|
|
iRet = H5Sselect_hyperslab(memspace, H5S_SELECT_SET, mStart,
|
|
NULL, mySize, NULL);
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: Select memspace failed");
|
|
return NX_ERROR;
|
|
}
|
|
/* map datatypes of other plateforms */
|
|
if (data_id == H5T_STRING) {
|
|
dims = H5Tget_size(pFile->iCurrentT);
|
|
memtype_id = H5Tcopy(H5T_C_S1);
|
|
H5Tset_size(memtype_id, dims);
|
|
} else {
|
|
memtype_id = h5MemType(pFile->iCurrentT);
|
|
}
|
|
|
|
/* read slab */
|
|
if (mtype == NX_CHAR) {
|
|
iRet = H5Dread(pFile->iCurrentD, memtype_id, H5S_ALL,
|
|
H5S_ALL, H5P_DEFAULT, tmp_data);
|
|
data1 = tmp_data + myStart[0];
|
|
strncpy(data, data1, (hsize_t) iSize[0]);
|
|
free(tmp_data);
|
|
} else {
|
|
iRet = H5Dread(pFile->iCurrentD, memtype_id, memspace,
|
|
pFile->iCurrentS, H5P_DEFAULT, data);
|
|
}
|
|
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR: Reading slab failed");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
/* Operator function. */
|
|
|
|
herr_t attr_info(hid_t loc_id, const char *name, void *opdata)
|
|
{
|
|
*((char **) opdata) = strdup(name);
|
|
return 1;
|
|
}
|
|
|
|
NXstatus NX5getnextattr(NXhandle fileid, NXname pName,
|
|
int *iLength, int *iType)
|
|
{
|
|
pNexusFile5 pFile;
|
|
hid_t attr_id, size_id, sign_id;
|
|
hid_t iRet, atype, aspace;
|
|
int iPType, rank;
|
|
char *iname = NULL;
|
|
unsigned int idx;
|
|
int intern_idx = -1;
|
|
int vid;
|
|
|
|
|
|
pFile = NXI5assert(fileid);
|
|
|
|
vid = getAttVID(pFile);
|
|
|
|
idx = pFile->iAtt5.iCurrentIDX;
|
|
iRet = 0;
|
|
intern_idx = H5Aget_num_attrs(vid);
|
|
if (intern_idx == idx) {
|
|
killAttVID(pFile, vid);
|
|
return NX_EOD;
|
|
}
|
|
|
|
if (intern_idx > idx) {
|
|
iRet = H5Aiterate(vid, &idx, attr_info, &iname);
|
|
} else {
|
|
iRet = 0;
|
|
}
|
|
intern_idx = -1;
|
|
if (iRet < 0) {
|
|
NXIReportError(NXpData, "ERROR iterating through attribute list!");
|
|
killAttVID(pFile, vid);
|
|
return NX_ERROR;
|
|
}
|
|
pFile->iAtt5.iCurrentIDX++;
|
|
if (iname != NULL) {
|
|
if (strcmp(iname, "NX_class") == 0 && pFile->iCurrentG != 0) {
|
|
/*
|
|
skip NXclass attribute which is internal
|
|
*/
|
|
killAttVID(pFile, vid);
|
|
return NX5getnextattr(fileid, pName, iLength, iType);
|
|
}
|
|
strcpy(pName, iname);
|
|
free(iname);
|
|
iname = NULL;
|
|
} else {
|
|
strcpy(pName, "What is this?");
|
|
}
|
|
pFile->iCurrentA = H5Aopen_name(vid, pName);
|
|
atype = H5Aget_type(pFile->iCurrentA);
|
|
aspace = H5Aget_space(pFile->iCurrentA);
|
|
rank = H5Sget_simple_extent_ndims(aspace);
|
|
attr_id = H5Tget_class(atype);
|
|
if (attr_id == H5T_STRING) {
|
|
iPType = NX_CHAR;
|
|
rank = H5Tget_size(atype);
|
|
}
|
|
if (rank == 0) {
|
|
rank++;
|
|
}
|
|
iPType = hdf5ToNXType(attr_id, atype);
|
|
*iType = iPType;
|
|
*iLength = rank;
|
|
H5Tclose(atype);
|
|
H5Sclose(aspace);
|
|
H5Aclose(pFile->iCurrentA);
|
|
|
|
intern_idx = H5Aget_num_attrs(vid);
|
|
|
|
killAttVID(pFile, vid);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5getattr(NXhandle fid, char *name,
|
|
void *data, int *datalen, int *iType)
|
|
{
|
|
pNexusFile5 pFile;
|
|
int iNew, iRet, vid;
|
|
hid_t type, atype = -1, glob;
|
|
char pBuffer[256];
|
|
|
|
pFile = NXI5assert(fid);
|
|
type = *iType;
|
|
glob = 0;
|
|
|
|
type = nxToHDF5Type(type);
|
|
|
|
vid = getAttVID(pFile);
|
|
iNew = H5Aopen_name(vid, name);
|
|
if (iNew < 0) {
|
|
sprintf(pBuffer, "ERROR: attribute %s not found", name);
|
|
killAttVID(pFile, vid);
|
|
NXIReportError(NXpData, pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
pFile->iCurrentA = iNew;
|
|
/* finally read the data */
|
|
if (type == H5T_C_S1) {
|
|
atype = H5Tcopy(type);
|
|
H5Tset_size(atype, *datalen);
|
|
iRet = H5Aread(pFile->iCurrentA, atype, data);
|
|
*datalen = strlen(data);
|
|
} else {
|
|
iRet = H5Aread(pFile->iCurrentA, type, data);
|
|
*datalen = 1;
|
|
}
|
|
|
|
if (iRet < 0) {
|
|
sprintf(pBuffer, "ERROR: HDF could not read attribute data");
|
|
NXIReportError(NXpData, pBuffer);
|
|
killAttVID(pFile, vid);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
iRet = H5Aclose(pFile->iCurrentA);
|
|
|
|
killAttVID(pFile, vid);
|
|
if (type == H5T_C_S1) {
|
|
H5Tclose(atype);
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5getattrinfo(NXhandle fid, int *iN)
|
|
{
|
|
pNexusFile5 pFile;
|
|
char *iname = NULL;
|
|
unsigned int idx;
|
|
int vid;
|
|
herr_t iRet;
|
|
|
|
pFile = NXI5assert(fid);
|
|
idx = 0;
|
|
*iN = idx;
|
|
|
|
vid = getAttVID(pFile);
|
|
|
|
idx = H5Aget_num_attrs(vid);
|
|
if (idx > 0) {
|
|
if (pFile->iCurrentG > 0 && pFile->iCurrentD == 0) {
|
|
*iN = idx - 1;
|
|
} else {
|
|
*iN = idx;
|
|
}
|
|
} else {
|
|
*iN = 0;
|
|
}
|
|
killAttVID(pFile, vid);
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
NXstatus NX5getgroupID(NXhandle fileid, NXlink * sRes)
|
|
{
|
|
pNexusFile5 pFile;
|
|
int u, datalen, type = NX_CHAR;
|
|
char group_name[64], class_name[64];
|
|
ErrFunc oldErr;
|
|
|
|
pFile = NXI5assert(fileid);
|
|
if (pFile->iCurrentG == 0) {
|
|
return NX_ERROR;
|
|
} else {
|
|
/*
|
|
this means: if the item is already linked: use the target attribute, else
|
|
the path to the current node
|
|
*/
|
|
oldErr = NXMGetError();
|
|
NXMSetError(NXpData, ignoreError);
|
|
datalen = 1024;
|
|
memset(sRes->targetPath, 0, datalen * sizeof(char));
|
|
if (NX5getattr(fileid, "target", sRes->targetPath, &datalen, &type) !=
|
|
NX_OK) {
|
|
buildCurrentPath(pFile, sRes->targetPath, 1024);
|
|
}
|
|
NXMSetError(NXpData, oldErr);
|
|
sRes->linkType = 0;
|
|
return NX_OK;
|
|
}
|
|
/* not reached */
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX5sameID(NXhandle fileid, NXlink * pFirstID, NXlink * pSecondID)
|
|
{
|
|
pNexusFile5 pFile;
|
|
|
|
pFile = NXI5assert(fileid);
|
|
if ((strcmp(pFirstID->targetPath, pSecondID->targetPath) == 0)) {
|
|
return NX_OK;
|
|
} else {
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5initattrdir(NXhandle fid)
|
|
{
|
|
pNexusFile5 pFile;
|
|
|
|
pFile = NXI5assert(fid);
|
|
NXI5KillAttDir(fid);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX5initgroupdir(NXhandle fid)
|
|
{
|
|
pNexusFile5 pFile;
|
|
|
|
pFile = NXI5assert(fid);
|
|
NXI5KillDir(fid);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
void NX5assignFunctions(pNexusFunction fHandle)
|
|
{
|
|
|
|
fHandle->nxclose = NX5close;
|
|
fHandle->nxflush = NX5flush;
|
|
fHandle->nxmakegroup = NX5makegroup;
|
|
fHandle->nxopengroup = NX5opengroup;
|
|
fHandle->nxclosegroup = NX5closegroup;
|
|
fHandle->nxmakedata = NX5makedata;
|
|
fHandle->nxcompmakedata = NX5compmakedata;
|
|
fHandle->nxcompress = NX5compress;
|
|
fHandle->nxopendata = NX5opendata;
|
|
fHandle->nxclosedata = NX5closedata;
|
|
fHandle->nxputdata = NX5putdata;
|
|
fHandle->nxputattr = NX5putattr;
|
|
fHandle->nxputslab = NX5putslab;
|
|
fHandle->nxgetdataID = NX5getdataID;
|
|
fHandle->nxmakelink = NX5makelink;
|
|
fHandle->nxmakenamedlink = NX5makenamedlink;
|
|
fHandle->nxgetdata = NX5getdata;
|
|
fHandle->nxgetinfo = NX5getinfo;
|
|
fHandle->nxgetnextentry = NX5getnextentry;
|
|
fHandle->nxgetslab = NX5getslab;
|
|
fHandle->nxgetnextattr = NX5getnextattr;
|
|
fHandle->nxgetattr = NX5getattr;
|
|
fHandle->nxgetattrinfo = NX5getattrinfo;
|
|
fHandle->nxgetgroupID = NX5getgroupID;
|
|
fHandle->nxgetgroupinfo = NX5getgroupinfo;
|
|
fHandle->nxsameID = NX5sameID;
|
|
fHandle->nxinitgroupdir = NX5initgroupdir;
|
|
fHandle->nxinitattrdir = NX5initattrdir;
|
|
fHandle->nxprintlink = NX5printlink;
|
|
}
|