1984 lines
54 KiB
C
1984 lines
54 KiB
C
/*---------------------------------------------------------------------------
|
|
NeXus - Neutron & X-ray Common Data Format
|
|
|
|
Application Program Interface (HDF4) 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.nexusformat.org>
|
|
|
|
$Id$
|
|
|
|
----------------------------------------------------------------------------*/
|
|
|
|
#ifdef HDF4
|
|
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#include "napi.h"
|
|
#include "napi4.h"
|
|
|
|
extern void *NXpData;
|
|
|
|
typedef struct __NexusFile {
|
|
struct iStack {
|
|
int32 *iRefDir;
|
|
int32 *iTagDir;
|
|
int32 iVref;
|
|
int32 __iStack_pad;
|
|
int iNDir;
|
|
int iCurDir;
|
|
} iStack[NXMAXSTACK];
|
|
struct iStack iAtt;
|
|
int32 iVID;
|
|
int32 iSID;
|
|
int32 iCurrentVG;
|
|
int32 iCurrentSDS;
|
|
int iNXID;
|
|
int iStackPtr;
|
|
char iAccess[2];
|
|
} NexusFile, *pNexusFile;
|
|
/*-------------------------------------------------------------------*/
|
|
|
|
static pNexusFile NXIassert(NXhandle fid)
|
|
{
|
|
pNexusFile pRes;
|
|
|
|
assert(fid != NULL);
|
|
pRes = (pNexusFile)fid;
|
|
assert(pRes->iNXID == NXSIGNATURE);
|
|
return pRes;
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
static int findNapiClass(pNexusFile pFile, int groupRef, NXname nxclass)
|
|
{
|
|
NXname classText, linkClass;
|
|
int32 tags[2], attID, linkID, groupID;
|
|
|
|
groupID = Vattach(pFile->iVID,groupRef,"r");
|
|
Vgetclass(groupID, classText);
|
|
if(strcmp(classText,"NAPIlink") != 0)
|
|
{
|
|
/* normal group */
|
|
strcpy(nxclass,classText);
|
|
Vdetach(groupID);
|
|
return groupRef;
|
|
}
|
|
else
|
|
{
|
|
/* code for linked renamed groups */
|
|
attID = Vfindattr(groupID,"NAPIlink");
|
|
if(attID >= 0)
|
|
{
|
|
Vgetattr(groupID,attID, tags);
|
|
linkID = Vattach(pFile->iVID,tags[1],"r");
|
|
Vgetclass(linkID, linkClass);
|
|
Vdetach(groupID);
|
|
Vdetach(linkID);
|
|
strcpy(nxclass,linkClass);
|
|
return tags[1];
|
|
}
|
|
else
|
|
{
|
|
/* this allows for finding the NAPIlink group in NXmakenamedlink */
|
|
strcpy(nxclass,classText);
|
|
Vdetach(groupID);
|
|
return groupRef;
|
|
}
|
|
}
|
|
}
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static int32 NXIFindVgroup (pNexusFile pFile, CONSTCHAR *name, CONSTCHAR *nxclass)
|
|
{
|
|
int32 iNew, iRef, iTag;
|
|
int iN, i;
|
|
int32 *pArray = NULL;
|
|
NXname pText;
|
|
|
|
assert (pFile != NULL);
|
|
|
|
if (pFile->iCurrentVG == 0) { /* root level */
|
|
/* get the number and ID's of all lone Vgroups in the file */
|
|
iN = Vlone (pFile->iVID, NULL, 0);
|
|
if(iN == 0) {
|
|
return NX_EOD;
|
|
}
|
|
pArray = (int32 *) malloc (iN * sizeof (int32));
|
|
if (!pArray) {
|
|
NXReportError( "ERROR: out of memory in NXIFindVgroup");
|
|
return NX_EOD;
|
|
}
|
|
Vlone (pFile->iVID, pArray, iN);
|
|
|
|
/* loop and check */
|
|
for (i = 0; i < iN; i++) {
|
|
iNew = Vattach (pFile->iVID, pArray[i], "r");
|
|
Vgetname (iNew, pText);
|
|
Vdetach(iNew);
|
|
if (strcmp (pText, name) == 0) {
|
|
pArray[i] = findNapiClass(pFile,pArray[i],pText);
|
|
if (strcmp (pText, nxclass) == 0) {
|
|
/* found ! */
|
|
iNew = pArray[i];
|
|
free (pArray);
|
|
return iNew;
|
|
}
|
|
}
|
|
}
|
|
/* nothing found */
|
|
free (pArray);
|
|
return NX_EOD;
|
|
} else { /* case in Vgroup */
|
|
iN = Vntagrefs (pFile->iCurrentVG);
|
|
for (i = 0; i < iN; i++) {
|
|
Vgettagref (pFile->iCurrentVG, i, &iTag, &iRef);
|
|
if (iTag == DFTAG_VG) {
|
|
iNew = Vattach (pFile->iVID, iRef, "r");
|
|
Vgetname (iNew, pText);
|
|
Vdetach(iNew);
|
|
if (strcmp (pText, name) == 0) {
|
|
iRef = findNapiClass(pFile,iRef, pText);
|
|
if (strcmp (pText, nxclass) == 0) {
|
|
return iRef;
|
|
}
|
|
}
|
|
}
|
|
} /* end for */
|
|
} /* end else */
|
|
/* not found */
|
|
return NX_EOD;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static int32 NXIFindSDS (NXhandle fid, CONSTCHAR *name)
|
|
{
|
|
pNexusFile self;
|
|
int32 iNew, iRet, iTag, iRef;
|
|
int32 i, iN, iA, iD1, iD2;
|
|
NXname pNam;
|
|
int32 iDim[H4_MAX_VAR_DIMS];
|
|
|
|
self = NXIassert (fid);
|
|
|
|
/* root level search */
|
|
if (self->iCurrentVG == 0) {
|
|
i = SDfileinfo (self->iSID, &iN, &iA);
|
|
if (i < 0) {
|
|
NXReportError( "ERROR: failure to read file information");
|
|
return NX_EOD;
|
|
}
|
|
for (i = 0; i < iN; i++) {
|
|
iNew = SDselect (self->iSID, i);
|
|
SDgetinfo (iNew, pNam, &iA, iDim, &iD1, &iD2);
|
|
if (strcmp (pNam, name) == 0) {
|
|
iRet = SDidtoref (iNew);
|
|
SDendaccess (iNew);
|
|
return iRet;
|
|
} else {
|
|
SDendaccess (iNew);
|
|
}
|
|
}
|
|
/* not found */
|
|
return NX_EOD;
|
|
}
|
|
/* end root level */
|
|
else { /* search in a Vgroup */
|
|
iN = Vntagrefs (self->iCurrentVG);
|
|
for (i = 0; i < iN; i++) {
|
|
Vgettagref (self->iCurrentVG, i, &iTag, &iRef);
|
|
/* we are now writing using DFTAG_NDG, but need others for backward compatability */
|
|
if ((iTag == DFTAG_SDG) || (iTag == DFTAG_NDG) || (iTag == DFTAG_SDS)) {
|
|
iNew = SDreftoindex (self->iSID, iRef);
|
|
iNew = SDselect (self->iSID, iNew);
|
|
SDgetinfo (iNew, pNam, &iA, iDim, &iD1, &iD2);
|
|
if (strcmp (pNam, name) == 0) {
|
|
SDendaccess (iNew);
|
|
return iRef;
|
|
}
|
|
SDendaccess (iNew);
|
|
}
|
|
} /* end for */
|
|
} /* end Vgroup */
|
|
/* we get here, only if nothing found */
|
|
return NX_EOD;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static int NXIInitDir (pNexusFile self)
|
|
{
|
|
int i;
|
|
int32 iTag, iRef;
|
|
int iStackPtr;
|
|
|
|
/*
|
|
* Note: the +1 to various malloc() operations is to avoid a
|
|
* malloc(0), which is an error on some operating systems
|
|
*/
|
|
iStackPtr = self->iStackPtr;
|
|
if (self->iCurrentVG == 0 &&
|
|
self->iStack[iStackPtr].iRefDir == NULL) { /* root level */
|
|
/* get the number and ID's of all lone Vgroups in the file */
|
|
self->iStack[iStackPtr].iNDir = Vlone (self->iVID, NULL, 0);
|
|
self->iStack[iStackPtr].iRefDir =
|
|
(int32 *) malloc (self->iStack[iStackPtr].iNDir * sizeof (int32) + 1);
|
|
if (!self->iStack[iStackPtr].iRefDir) {
|
|
NXReportError( "ERROR: out of memory in NXIInitDir");
|
|
return NX_EOD;
|
|
}
|
|
Vlone (self->iVID,
|
|
self->iStack[self->iStackPtr].iRefDir,
|
|
self->iStack[self->iStackPtr].iNDir);
|
|
} else {
|
|
/* Vgroup level */
|
|
self->iStack[iStackPtr].iNDir = Vntagrefs (self->iCurrentVG);
|
|
self->iStack[iStackPtr].iRefDir =
|
|
(int32 *) malloc (self->iStack[iStackPtr].iNDir * sizeof (int32) + 1);
|
|
self->iStack[iStackPtr].iTagDir =
|
|
(int32 *) malloc (self->iStack[iStackPtr].iNDir * sizeof (int32) + 1);
|
|
if ((!self->iStack[iStackPtr].iRefDir) ||
|
|
(!self->iStack[iStackPtr].iTagDir)) {
|
|
NXReportError( "ERROR: out of memory in NXIInitDir");
|
|
return NX_EOD;
|
|
}
|
|
for (i = 0; i < self->iStack[self->iStackPtr].iNDir; i++) {
|
|
Vgettagref (self->iCurrentVG, i, &iTag, &iRef);
|
|
self->iStack[iStackPtr].iRefDir[i] = iRef;
|
|
self->iStack[iStackPtr].iTagDir[i] = iTag;
|
|
}
|
|
}
|
|
self->iStack[iStackPtr].iCurDir = 0;
|
|
return 1;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void NXIKillDir (pNexusFile self)
|
|
{
|
|
if (self->iStack[self->iStackPtr].iRefDir) {
|
|
free (self->iStack[self->iStackPtr].iRefDir);
|
|
self->iStack[self->iStackPtr].iRefDir = NULL;
|
|
}
|
|
if (self->iStack[self->iStackPtr].iTagDir) {
|
|
free (self->iStack[self->iStackPtr].iTagDir);
|
|
self->iStack[self->iStackPtr].iTagDir = NULL;
|
|
}
|
|
self->iStack[self->iStackPtr].iCurDir = 0;
|
|
self->iStack[self->iStackPtr].iNDir = 0;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
static int NXIInitAttDir (pNexusFile pFile)
|
|
{
|
|
int iRet;
|
|
int32 iData, iAtt, iRank, iType;
|
|
int32 iDim[H4_MAX_VAR_DIMS];
|
|
NXname pNam;
|
|
|
|
pFile->iAtt.iCurDir = 0;
|
|
if (pFile->iCurrentSDS != 0) { /* SDS level */
|
|
iRet = SDgetinfo (pFile->iCurrentSDS, pNam, &iRank, iDim, &iType,
|
|
&iAtt);
|
|
} else {
|
|
if(pFile->iCurrentVG == 0){
|
|
/* global level */
|
|
iRet = SDfileinfo (pFile->iSID, &iData, &iAtt);
|
|
} else {
|
|
/* group attribute */
|
|
iRet = Vnattrs(pFile->iCurrentVG);
|
|
iAtt = iRet;
|
|
}
|
|
}
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot read attribute numbers");
|
|
pFile->iAtt.iNDir = 0;
|
|
return NX_ERROR;
|
|
}
|
|
pFile->iAtt.iNDir = iAtt;
|
|
return NX_OK;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
static void NXIKillAttDir (pNexusFile self)
|
|
{
|
|
if (self->iAtt.iRefDir) {
|
|
free (self->iAtt.iRefDir);
|
|
self->iAtt.iRefDir = NULL;
|
|
}
|
|
if (self->iAtt.iTagDir) {
|
|
free (self->iAtt.iTagDir);
|
|
self->iAtt.iTagDir = NULL;
|
|
}
|
|
self->iAtt.iCurDir = 0;
|
|
self->iAtt.iNDir = 0;
|
|
}
|
|
/*------------------------------------------------------------------*/
|
|
static void NXIbuildPath(pNexusFile pFile, char *buffer, int bufLen)
|
|
{
|
|
int i;
|
|
int32 groupID, iA, iD1, iD2, iDim[H4_MAX_VAR_DIMS];
|
|
NXname pText;
|
|
|
|
buffer[0] = '\0';
|
|
for(i = 1; i <= pFile->iStackPtr; i++){
|
|
strncat(buffer,"/",bufLen-strlen(buffer));
|
|
groupID = Vattach(pFile->iVID,pFile->iStack[i].iVref, "r");
|
|
if (groupID != -1)
|
|
{
|
|
if (Vgetname(groupID, pText) != -1) {
|
|
strncat(buffer,pText,bufLen-strlen(buffer));
|
|
} else {
|
|
NXReportError( "ERROR: NXIbuildPath cannot get vgroup name");
|
|
}
|
|
Vdetach(groupID);
|
|
}
|
|
else
|
|
{
|
|
NXReportError( "ERROR: NXIbuildPath cannot attach to vgroup");
|
|
}
|
|
}
|
|
if(pFile->iCurrentSDS != 0){
|
|
if (SDgetinfo(pFile->iCurrentSDS,pText,&iA,iDim,&iD1,&iD2) != -1) {
|
|
strncat(buffer,"/",bufLen-strlen(buffer));
|
|
strncat(buffer,pText,bufLen-strlen(buffer));
|
|
}
|
|
else
|
|
{
|
|
NXReportError( "ERROR: NXIbuildPath cannot read SDS");
|
|
}
|
|
}
|
|
}
|
|
/* ----------------------------------------------------------------------
|
|
|
|
Definition of NeXus API
|
|
|
|
---------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4open(CONSTCHAR *filename, NXaccess am,
|
|
NXhandle* pHandle)
|
|
{
|
|
pNexusFile pNew = NULL;
|
|
char pBuffer[512];
|
|
char *time_puffer = NULL;
|
|
char HDF_VERSION[64];
|
|
uint32 lmajor, lminor, lrelease;
|
|
int32 am1=0;
|
|
|
|
*pHandle = NULL;
|
|
|
|
/* mask off any options for now */
|
|
am = (NXaccess)(am & NXACCMASK_REMOVEFLAGS);
|
|
/* map Nexus NXaccess types to HDF4 types */
|
|
if (am == NXACC_CREATE) {
|
|
am1 = DFACC_CREATE;
|
|
} else if (am == NXACC_CREATE4) {
|
|
am1 = DFACC_CREATE;
|
|
} else if (am == NXACC_READ) {
|
|
am1 = DFACC_READ;
|
|
} else if (am == NXACC_RDWR) {
|
|
am1 = DFACC_RDWR;
|
|
}
|
|
/* get memory */
|
|
pNew = (pNexusFile) malloc (sizeof (NexusFile));
|
|
if (!pNew) {
|
|
NXReportError( "ERROR: no memory to create File datastructure");
|
|
return NX_ERROR;
|
|
}
|
|
memset (pNew, 0, sizeof (NexusFile));
|
|
|
|
#if WRITE_OLD_IDENT /* not used at moment */
|
|
/*
|
|
* write something that can be used by OLE
|
|
*/
|
|
|
|
if (am == NXACC_CREATE || am == NXACC_CREATE4) {
|
|
if ( (file_id = Hopen(filename, am1, 0)) == -1 ) {
|
|
sprintf (pBuffer, "ERROR: cannot open file_a: %s", filename);
|
|
NXReportError( pBuffer);
|
|
free (pNew);
|
|
return NX_ERROR;
|
|
}
|
|
an_id = ANstart(file_id);
|
|
ann_id = ANcreatef(an_id, AN_FILE_LABEL); /* AN_FILE_DESC */
|
|
ANwriteann(ann_id, "NeXus", 5);
|
|
ANendaccess(ann_id);
|
|
ANend(an_id);
|
|
if (Hclose(file_id) == -1) {
|
|
sprintf (pBuffer, "ERROR: cannot close file: %s", filename);
|
|
NXReportError( pBuffer);
|
|
free (pNew);
|
|
return NX_ERROR;
|
|
}
|
|
am = NXACC_RDWR;
|
|
}
|
|
#endif /* WRITE_OLD_IDENT */
|
|
|
|
/* start SDS interface */
|
|
pNew->iSID = SDstart (filename, am1);
|
|
if (pNew->iSID <= 0) {
|
|
sprintf (pBuffer, "ERROR: cannot open file_b: %s", filename);
|
|
NXReportError( pBuffer);
|
|
free (pNew);
|
|
return NX_ERROR;
|
|
}
|
|
/*
|
|
* need to create global attributes file_name file_time NeXus_version
|
|
* at some point for new files
|
|
*/
|
|
if (am != NXACC_READ) {
|
|
if (SDsetattr(pNew->iSID, "NeXus_version", DFNT_CHAR8, strlen(NEXUS_VERSION), NEXUS_VERSION) < 0) {
|
|
NXReportError( "ERROR: HDF failed to store NeXus_version attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
Hgetlibversion(&lmajor, &lminor, &lrelease, HDF_VERSION);
|
|
if (SDsetattr(pNew->iSID, "HDF_version", DFNT_CHAR8, strlen(HDF_VERSION), HDF_VERSION) < 0) {
|
|
NXReportError( "ERROR: HDF failed to store HDF_version attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
|
|
time_puffer = NXIformatNeXusTime();
|
|
if (am == NXACC_CREATE || am == NXACC_CREATE4) {
|
|
if (SDsetattr(pNew->iSID, "file_name", DFNT_CHAR8, strlen(filename), (char*)filename) < 0) {
|
|
NXReportError( "ERROR: HDF failed to store file_name attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
if(time_puffer != NULL){
|
|
if (SDsetattr(pNew->iSID, "file_time", DFNT_CHAR8,
|
|
strlen(time_puffer), time_puffer) < 0) {
|
|
NXReportError(
|
|
"ERROR: HDF failed to store file_time attribute ");
|
|
free(time_puffer);
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
}
|
|
if (time_puffer != NULL) {
|
|
free(time_puffer);
|
|
}
|
|
|
|
/*
|
|
* Otherwise we try to create the file two times which makes HDF
|
|
* Throw up on us.
|
|
*/
|
|
if (am == NXACC_CREATE || am == NXACC_CREATE4) {
|
|
am = NXACC_RDWR;
|
|
am1 = DFACC_RDWR;
|
|
}
|
|
|
|
/* Set Vgroup access mode */
|
|
if (am == NXACC_READ) {
|
|
strcpy(pNew->iAccess,"r");
|
|
} else {
|
|
strcpy(pNew->iAccess,"w");
|
|
}
|
|
|
|
/* start Vgroup API */
|
|
|
|
pNew->iVID = Hopen(filename, am1, 100);
|
|
if (pNew->iVID <= 0) {
|
|
sprintf (pBuffer, "ERROR: cannot open file_c: %s", filename);
|
|
NXReportError( pBuffer);
|
|
free (pNew);
|
|
return NX_ERROR;
|
|
}
|
|
Vstart (pNew->iVID);
|
|
pNew->iNXID = NXSIGNATURE;
|
|
pNew->iStack[0].iVref = 0; /* root! */
|
|
|
|
*pHandle = (NXhandle)pNew;
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
NXstatus NX4close (NXhandle* fid)
|
|
{
|
|
pNexusFile pFile = NULL;
|
|
int iRet;
|
|
|
|
pFile = NXIassert(*fid);
|
|
iRet = 0;
|
|
/* close links into vGroups or SDS */
|
|
if (pFile->iCurrentVG != 0) {
|
|
Vdetach (pFile->iCurrentVG);
|
|
}
|
|
if (pFile->iCurrentSDS != 0) {
|
|
iRet = SDendaccess (pFile->iCurrentSDS);
|
|
}
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: ending access to SDS");
|
|
}
|
|
/* close the SDS and Vgroup API's */
|
|
Vend (pFile->iVID);
|
|
iRet = SDend (pFile->iSID);
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot close SDS interface");
|
|
}
|
|
iRet = Hclose (pFile->iVID);
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot close HDF file");
|
|
}
|
|
/* release memory */
|
|
NXIKillDir (pFile);
|
|
free (pFile);
|
|
*fid = NULL;
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/*-----------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4makegroup (NXhandle fid, CONSTCHAR *name, CONSTCHAR *nxclass)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iNew, iRet;
|
|
char pBuffer[256];
|
|
|
|
pFile = NXIassert (fid);
|
|
/*
|
|
* Make sure that a group with the same name and nxclass does not
|
|
* already exist.
|
|
*/
|
|
if ((iRet = NXIFindVgroup (pFile, (char*)name, nxclass)) >= 0) {
|
|
sprintf (pBuffer, "ERROR: Vgroup %s, class %s already exists",
|
|
name, nxclass);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/* create and configure the group */
|
|
iNew = Vattach (pFile->iVID, -1, "w");
|
|
if (iNew < 0) {
|
|
NXReportError( "ERROR: HDF could not create Vgroup");
|
|
return NX_ERROR;
|
|
}
|
|
Vsetname (iNew, name);
|
|
Vsetclass (iNew, nxclass);
|
|
|
|
/* Insert it into the hierarchy, when appropriate */
|
|
iRet = 0;
|
|
if (pFile->iCurrentVG != 0) {
|
|
iRet = Vinsert (pFile->iCurrentVG, iNew);
|
|
}
|
|
Vdetach (iNew);
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF failed to insert Vgroup");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/*------------------------------------------------------------------------*/
|
|
NXstatus NX4opengroup (NXhandle fid, CONSTCHAR *name, CONSTCHAR *nxclass)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iRef;
|
|
char pBuffer[256];
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
iRef = NXIFindVgroup (pFile, (char*)name, nxclass);
|
|
if (iRef < 0) {
|
|
sprintf (pBuffer, "ERROR: Vgroup \"%s\", class \"%s\" NOT found", name, nxclass);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
/* are we at root level ? */
|
|
if (pFile->iCurrentVG == 0) {
|
|
pFile->iCurrentVG = Vattach (pFile->iVID, iRef,pFile->iAccess);
|
|
pFile->iStackPtr++;
|
|
pFile->iStack[pFile->iStackPtr].iVref = iRef;
|
|
} else {
|
|
Vdetach (pFile->iCurrentVG);
|
|
pFile->iStackPtr++;
|
|
pFile->iStack[pFile->iStackPtr].iVref = iRef;
|
|
pFile->iCurrentVG = Vattach (pFile->iVID,
|
|
pFile->iStack[pFile->iStackPtr].iVref,
|
|
pFile->iAccess);
|
|
}
|
|
NXIKillDir (pFile);
|
|
return NX_OK;
|
|
}
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4closegroup (NXhandle fid)
|
|
{
|
|
pNexusFile pFile;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* first catch the trivial case: we are at root and cannot get
|
|
deeper into a negative directory hierarchy (anti-directory)
|
|
*/
|
|
if (pFile->iCurrentVG == 0) {
|
|
NXIKillDir (pFile);
|
|
return NX_OK;
|
|
} else { /* Sighhh. Some work to do */
|
|
/* close the current VG and decrement stack */
|
|
Vdetach (pFile->iCurrentVG);
|
|
NXIKillDir (pFile);
|
|
pFile->iStackPtr--;
|
|
if (pFile->iStackPtr <= 0) { /* we hit root */
|
|
pFile->iStackPtr = 0;
|
|
pFile->iCurrentVG = 0;
|
|
} else {
|
|
/* attach to the lower Vgroup */
|
|
pFile->iCurrentVG = Vattach (pFile->iVID,
|
|
pFile->iStack[pFile->iStackPtr].iVref,
|
|
pFile->iAccess);
|
|
}
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
NXstatus NX4makedata64 (NXhandle fid, CONSTCHAR *name, int datatype, int rank,
|
|
int64_t dimensions[])
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iNew;
|
|
char pBuffer[256];
|
|
int i, iRet, type;
|
|
int32 myDim[H4_MAX_VAR_DIMS];
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
if (dimensions[0] == NX_UNLIMITED)
|
|
{
|
|
dimensions[0] = SD_UNLIMITED;
|
|
}
|
|
|
|
if ((iNew = NXIFindSDS (fid, name))>=0) {
|
|
sprintf (pBuffer, "ERROR: SDS %s already exists at this level", name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
if (datatype == NX_CHAR)
|
|
{
|
|
type=DFNT_CHAR8;
|
|
}
|
|
else if (datatype == NX_INT8)
|
|
{
|
|
type=DFNT_INT8;
|
|
}
|
|
else if (datatype == NX_UINT8)
|
|
{
|
|
type=DFNT_UINT8;
|
|
}
|
|
else if (datatype == NX_INT16)
|
|
{
|
|
type=DFNT_INT16;
|
|
}
|
|
else if (datatype == NX_UINT16)
|
|
{
|
|
type=DFNT_UINT16;
|
|
}
|
|
else if (datatype == NX_INT32)
|
|
{
|
|
type=DFNT_INT32;
|
|
}
|
|
else if (datatype == NX_UINT32)
|
|
{
|
|
type=DFNT_UINT32;
|
|
}
|
|
else if (datatype == NX_FLOAT32)
|
|
{
|
|
type=DFNT_FLOAT32;
|
|
}
|
|
else if (datatype == NX_FLOAT64)
|
|
{
|
|
type=DFNT_FLOAT64;
|
|
}
|
|
else
|
|
{
|
|
NXReportError( "ERROR: invalid type in NX4makedata");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
if (rank <= 0) {
|
|
sprintf (pBuffer, "ERROR: invalid rank specified for SDS %s",
|
|
name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/*
|
|
Check dimensions for consistency. The first dimension may be 0
|
|
thus denoting an unlimited dimension.
|
|
*/
|
|
for (i = 1; i < rank; i++) {
|
|
if (dimensions[i] <= 0) {
|
|
sprintf (pBuffer,
|
|
"ERROR: invalid dimension %d, value %lld given for SDS %s",
|
|
i, (long long)dimensions[i], name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
|
|
/* cast the dimensions array properly for non 32-bit ints */
|
|
for(i = 0; i < rank; i++)
|
|
{
|
|
myDim[i] = (int32)dimensions[i];
|
|
}
|
|
|
|
|
|
/* behave nicely, if there is still an SDS open */
|
|
if (pFile->iCurrentSDS != 0) {
|
|
SDendaccess (pFile->iCurrentSDS);
|
|
pFile->iCurrentSDS = 0;
|
|
}
|
|
|
|
/* Do not allow creation of SDS's at the root level */
|
|
if (pFile->iCurrentVG == 0) {
|
|
sprintf(pBuffer, "ERROR: SDS creation at root level is not permitted");
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/* dataset creation */
|
|
iNew = SDcreate (pFile->iSID, (char*)name, (int32)type,
|
|
(int32)rank, myDim);
|
|
if (iNew < 0) {
|
|
sprintf (pBuffer, "ERROR: cannot create SDS %s, check arguments",
|
|
name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
/* link into Vgroup, if in one */
|
|
if (pFile->iCurrentVG != 0) {
|
|
iRet = Vaddtagref (pFile->iCurrentVG, DFTAG_NDG, SDidtoref (iNew));
|
|
}
|
|
iRet = SDendaccess (iNew);
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot end access to SDS");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4compmakedata64 (NXhandle fid, CONSTCHAR *name, int datatype, int rank,
|
|
int64_t dimensions[],int compress_type, int64_t chunk_size[])
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iNew, iRet, type;
|
|
char pBuffer[256];
|
|
int i, compress_level;
|
|
int32 myDim[H4_MAX_VAR_DIMS];
|
|
comp_info compstruct;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
if (dimensions[0] == NX_UNLIMITED)
|
|
{
|
|
dimensions[0] = SD_UNLIMITED;
|
|
}
|
|
|
|
if ((iNew = NXIFindSDS (fid, name))>=0) {
|
|
sprintf (pBuffer, "ERROR: SDS %s already exists at this level", name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
if (datatype == NX_CHAR)
|
|
{
|
|
type=DFNT_CHAR8;
|
|
}
|
|
else if (datatype == NX_INT8)
|
|
{
|
|
type=DFNT_INT8;
|
|
}
|
|
else if (datatype == NX_UINT8)
|
|
{
|
|
type=DFNT_UINT8;
|
|
}
|
|
else if (datatype == NX_INT16)
|
|
{
|
|
type=DFNT_INT16;
|
|
}
|
|
else if (datatype == NX_UINT16)
|
|
{
|
|
type=DFNT_UINT16;
|
|
}
|
|
else if (datatype == NX_INT32)
|
|
{
|
|
type=DFNT_INT32;
|
|
}
|
|
else if (datatype == NX_UINT32)
|
|
{
|
|
type=DFNT_UINT32;
|
|
}
|
|
else if (datatype == NX_FLOAT32)
|
|
{
|
|
type=DFNT_FLOAT32;
|
|
}
|
|
else if (datatype == NX_FLOAT64)
|
|
{
|
|
type=DFNT_FLOAT64;
|
|
}
|
|
else
|
|
{
|
|
NXReportError( "ERROR: invalid datatype in NX4compmakedata");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
if (rank <= 0) {
|
|
sprintf (pBuffer, "ERROR: invalid rank specified for SDS %s",
|
|
name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/*
|
|
Check dimensions for consistency. The first dimension may be 0
|
|
thus denoting an unlimited dimension.
|
|
*/
|
|
for (i = 1; i < rank; i++) {
|
|
if (dimensions[i] <= 0) {
|
|
sprintf (pBuffer,
|
|
"ERROR: invalid dimension %d, value %lld given for SDS %s",
|
|
i, (long long)dimensions[i], name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
|
|
/* cast the dimensions array properly for non 32-bit ints */
|
|
for(i = 0; i < rank; i++)
|
|
{
|
|
myDim[i] = (int32)dimensions[i];
|
|
}
|
|
|
|
|
|
/* behave nicely, if there is still an SDS open */
|
|
if (pFile->iCurrentSDS != 0) {
|
|
SDendaccess (pFile->iCurrentSDS);
|
|
pFile->iCurrentSDS = 0;
|
|
}
|
|
|
|
/* Do not allow creation of SDS's at the root level */
|
|
if (pFile->iCurrentVG == 0) {
|
|
sprintf(pBuffer, "ERROR: SDS creation at root level is not permitted");
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/* dataset creation */
|
|
iNew = SDcreate (pFile->iSID, (char*)name, (int32)type,
|
|
(int32)rank, myDim);
|
|
if (iNew < 0) {
|
|
sprintf (pBuffer, "ERROR: cannot create SDS %s, check arguments",
|
|
name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/* compress SD data set */
|
|
compress_level = 6;
|
|
if( (compress_type / 100) == NX_COMP_LZW )
|
|
{
|
|
compress_level = compress_type % 100;
|
|
compress_type = NX_COMP_LZW;
|
|
}
|
|
|
|
if(compress_type == NX_COMP_LZW)
|
|
{
|
|
compstruct.deflate.level = compress_level;
|
|
iRet = SDsetcompress(iNew, COMP_CODE_DEFLATE, &compstruct);
|
|
if (iRet < 0)
|
|
{
|
|
NXReportError( "LZW-Compression failure!");
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
else if (compress_type == NX_COMP_RLE)
|
|
{
|
|
iRet = SDsetcompress(iNew, COMP_CODE_RLE, &compstruct);
|
|
if (iRet < 0)
|
|
{
|
|
NXReportError( "RLE-Compression failure!");
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
else if (compress_type == NX_COMP_HUF)
|
|
{
|
|
compstruct.skphuff.skp_size = DFKNTsize(type);
|
|
iRet = SDsetcompress(iNew, COMP_CODE_SKPHUFF, &compstruct);
|
|
if (iRet < 0)
|
|
{
|
|
NXReportError( "HUF-Compression failure!");
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
else if (compress_type == NX_COMP_NONE)
|
|
{
|
|
/* */
|
|
}
|
|
else
|
|
{
|
|
NXReportError( "Unknown compression method!");
|
|
return NX_ERROR;
|
|
}
|
|
/* link into Vgroup, if in one */
|
|
if (pFile->iCurrentVG != 0) {
|
|
iRet = Vaddtagref (pFile->iCurrentVG, DFTAG_NDG, SDidtoref (iNew));
|
|
}
|
|
iRet = SDendaccess (iNew);
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot end access to SDS");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
return NX_OK;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4compress (NXhandle fid, int compress_type)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iRank, iAtt, iType, iRet;
|
|
int32 iSize[H4_MAX_VAR_DIMS];
|
|
comp_coder_t compress_typei = COMP_CODE_NONE;
|
|
NXname pBuffer;
|
|
char pError[512];
|
|
comp_info compstruct;
|
|
int compress_level = 6;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* check if there is an SDS open */
|
|
if (pFile->iCurrentSDS == 0) {
|
|
NXReportError( "ERROR: no SDS open");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
if (compress_type == NX_COMP_NONE)
|
|
{
|
|
compress_typei = COMP_CODE_NONE;
|
|
}
|
|
else if (compress_type == NX_COMP_LZW)
|
|
{
|
|
compress_typei = COMP_CODE_DEFLATE;
|
|
}
|
|
else if ( (compress_type / 100) == NX_COMP_LZW )
|
|
{
|
|
compress_typei = COMP_CODE_DEFLATE;
|
|
compress_level = compress_type % 100;
|
|
compress_type = NX_COMP_LZW;
|
|
}
|
|
else if (compress_type == NX_COMP_RLE)
|
|
{
|
|
compress_typei = COMP_CODE_RLE;
|
|
}
|
|
else if
|
|
(compress_type == NX_COMP_HUF)
|
|
{
|
|
compress_typei = COMP_CODE_SKPHUFF;
|
|
}
|
|
|
|
/* first read dimension information */
|
|
SDgetinfo (pFile->iCurrentSDS, pBuffer, &iRank, iSize, &iType, &iAtt);
|
|
|
|
/*
|
|
according to compression type initialize compression
|
|
information
|
|
*/
|
|
if(compress_type == NX_COMP_LZW)
|
|
{
|
|
compstruct.deflate.level = compress_level;
|
|
}
|
|
else if(compress_type == NX_COMP_HUF)
|
|
{
|
|
compstruct.skphuff.skp_size = DFKNTsize(iType);
|
|
}
|
|
|
|
iRet = SDsetcompress(pFile->iCurrentSDS, compress_typei, &compstruct);
|
|
if (iRet < 0) {
|
|
sprintf (pError, "ERROR: failure to compress data to %s", pBuffer);
|
|
NXReportError( pError);
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4opendata (NXhandle fid, CONSTCHAR *name)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iNew, attID, tags[2];
|
|
char pBuffer[256];
|
|
int iRet;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* First find the reference number of the SDS */
|
|
iNew = NXIFindSDS (fid, name);
|
|
if (iNew < 0) {
|
|
sprintf (pBuffer, "ERROR: SDS \"%s\" not found at this level", name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
/* Be nice: properly close the old open SDS silently if there is
|
|
* still an SDS open.
|
|
*/
|
|
if (pFile->iCurrentSDS) {
|
|
iRet = SDendaccess (pFile->iCurrentSDS);
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot end access to SDS");
|
|
}
|
|
}
|
|
/* clear pending attribute directories first */
|
|
NXIKillAttDir (pFile);
|
|
|
|
/* open the SDS, thereby watching for linked SDS under a different name */
|
|
iNew = SDreftoindex (pFile->iSID, iNew);
|
|
pFile->iCurrentSDS = SDselect (pFile->iSID, iNew);
|
|
attID = SDfindattr(pFile->iCurrentSDS,"NAPIlink");
|
|
if(attID >= 0)
|
|
{
|
|
SDreadattr(pFile->iCurrentSDS,attID, tags);
|
|
SDendaccess(pFile->iCurrentSDS);
|
|
iNew = SDreftoindex (pFile->iSID, tags[1]);
|
|
pFile->iCurrentSDS = SDselect (pFile->iSID, iNew);
|
|
}
|
|
|
|
if (pFile->iCurrentSDS < 0) {
|
|
NXReportError( "ERROR: HDF error opening SDS");
|
|
pFile->iCurrentSDS = 0;
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4closedata (NXhandle fid)
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
if (pFile->iCurrentSDS != 0) {
|
|
iRet = SDendaccess (pFile->iCurrentSDS);
|
|
pFile->iCurrentSDS = 0;
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot end access to SDS");
|
|
return NX_ERROR;
|
|
}
|
|
} else {
|
|
NXReportError( "ERROR: no SDS open --> nothing to do");
|
|
return NX_ERROR;
|
|
}
|
|
NXIKillAttDir (pFile); /* for attribute data */
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX4putdata (NXhandle fid, const void *data)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iStart[H4_MAX_VAR_DIMS], iSize[H4_MAX_VAR_DIMS], iStride[H4_MAX_VAR_DIMS];
|
|
NXname pBuffer;
|
|
int32 iRank, iAtt, iType, iRet, i;
|
|
char pError[512];
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* check if there is an SDS open */
|
|
if (pFile->iCurrentSDS == 0) {
|
|
NXReportError( "ERROR: no SDS open");
|
|
return NX_ERROR;
|
|
}
|
|
/* first read dimension information */
|
|
memset (iStart, 0, H4_MAX_VAR_DIMS * sizeof (int32));
|
|
SDgetinfo (pFile->iCurrentSDS, pBuffer, &iRank, iSize, &iType, &iAtt);
|
|
|
|
/* initialise stride to 1 */
|
|
for (i = 0; i < iRank; i++) {
|
|
iStride[i] = 1;
|
|
}
|
|
|
|
/* actually write */
|
|
iRet = SDwritedata (pFile->iCurrentSDS, iStart, iStride, iSize, (void*)data);
|
|
if (iRet < 0) {
|
|
/* HEprint(stdout,0); */
|
|
sprintf (pError, "ERROR: failure to write data to %s", pBuffer);
|
|
NXReportError( pError);
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus
|
|
NX4putattr (NXhandle fid, CONSTCHAR *name, const void *data, int datalen, int iType)
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet, type;
|
|
|
|
pFile = NXIassert (fid);
|
|
if (iType == NX_CHAR)
|
|
{
|
|
type=DFNT_CHAR8;
|
|
}
|
|
else if (iType == NX_INT8)
|
|
{
|
|
type=DFNT_INT8;
|
|
}
|
|
else if (iType == NX_UINT8)
|
|
{
|
|
type=DFNT_UINT8;
|
|
}
|
|
else if (iType == NX_INT16)
|
|
{
|
|
type=DFNT_INT16;
|
|
}
|
|
else if (iType == NX_UINT16)
|
|
{
|
|
type=DFNT_UINT16;
|
|
}
|
|
else if (iType == NX_INT32)
|
|
{
|
|
type=DFNT_INT32;
|
|
}
|
|
else if (iType == NX_UINT32)
|
|
{
|
|
type=DFNT_UINT32;
|
|
}
|
|
else if (iType == NX_FLOAT32)
|
|
{
|
|
type=DFNT_FLOAT32;
|
|
}
|
|
else if (iType == NX_FLOAT64)
|
|
{
|
|
type=DFNT_FLOAT64;
|
|
}
|
|
else
|
|
{
|
|
NXReportError( "ERROR: Invalid data type for HDF attribute");
|
|
return NX_ERROR;
|
|
}
|
|
if (pFile->iCurrentSDS != 0) {
|
|
/* SDS attribute */
|
|
iRet = SDsetattr (pFile->iCurrentSDS, (char*)name, (int32)type,
|
|
(int32)datalen, data);
|
|
} else {
|
|
if(pFile->iCurrentVG == 0){
|
|
/* global attribute */
|
|
iRet = SDsetattr (pFile->iSID, (char*)name, (int32)type,
|
|
(int32)datalen, data);
|
|
} else {
|
|
/* group attribute */
|
|
iRet = Vsetattr(pFile->iCurrentVG, (char *)name, (int32) type,
|
|
(int32)datalen,data);
|
|
}
|
|
}
|
|
iType = type;
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF failed to store attribute ");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4putslab64 (NXhandle fid, const void *data, const int64_t iStart[], const int64_t iSize[])
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet;
|
|
int32 iStride[H4_MAX_VAR_DIMS];
|
|
int32 myStart[H4_MAX_VAR_DIMS], mySize[H4_MAX_VAR_DIMS];
|
|
int32 i, iRank, iType, iAtt;
|
|
NXname pBuffer;
|
|
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* check if there is an SDS open */
|
|
if (pFile->iCurrentSDS == 0) {
|
|
NXReportError( "ERROR: no SDS open");
|
|
return NX_ERROR;
|
|
}
|
|
/* initialise stride to 1 */
|
|
for (i = 0; i < H4_MAX_VAR_DIMS; i++) {
|
|
iStride[i] = 1;
|
|
}
|
|
|
|
SDgetinfo (pFile->iCurrentSDS, pBuffer,
|
|
&iRank, myStart, &iType, &iAtt);
|
|
for(i = 0; i < iRank; i++)
|
|
{
|
|
myStart[i] = (int32)iStart[i];
|
|
mySize[i] = (int32)iSize[i];
|
|
}
|
|
/* finally write */
|
|
iRet = SDwritedata (pFile->iCurrentSDS, myStart,
|
|
iStride, mySize, (void*)data);
|
|
|
|
|
|
/* deal with HDF errors */
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: writing slab failed");
|
|
return NX_ERROR;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX4getdataID (NXhandle fid, NXlink* sRes)
|
|
{
|
|
pNexusFile pFile;
|
|
int datalen, type = NX_CHAR;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
if (pFile->iCurrentSDS == 0) {
|
|
sRes->iTag = NX_ERROR;
|
|
return NX_ERROR;
|
|
} else {
|
|
sRes->iTag = DFTAG_NDG;
|
|
sRes->iRef = SDidtoref (pFile->iCurrentSDS);
|
|
NXMDisableErrorReporting();
|
|
datalen = 1024;
|
|
memset(&sRes->targetPath,0,1024);
|
|
if(NX4getattr(fid,"target",&sRes->targetPath,&datalen,&type) != NX_OK)
|
|
{
|
|
NXIbuildPath(pFile,sRes->targetPath,1024);
|
|
}
|
|
NXMEnableErrorReporting();
|
|
return NX_OK;
|
|
}
|
|
sRes->iTag = NX_ERROR;
|
|
return NX_ERROR; /* not reached */
|
|
}
|
|
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4makelink (NXhandle fid, NXlink* sLink)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 dataID, type = DFNT_CHAR8, length;
|
|
char name[] = "target";
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
if (pFile->iCurrentVG == 0) { /* root level, can not link here */
|
|
return NX_ERROR;
|
|
}
|
|
Vaddtagref(pFile->iCurrentVG, sLink->iTag, sLink->iRef);
|
|
length = strlen(sLink->targetPath);
|
|
if(sLink->iTag == DFTAG_SDG || sLink->iTag == DFTAG_NDG ||
|
|
sLink->iTag == DFTAG_SDS)
|
|
{
|
|
dataID = SDreftoindex(pFile->iSID,sLink->iRef);
|
|
dataID = SDselect(pFile->iSID,dataID);
|
|
SDsetattr(dataID,name,type,length,sLink->targetPath);
|
|
SDendaccess(dataID);
|
|
}
|
|
else
|
|
{
|
|
dataID = Vattach(pFile->iVID,sLink->iRef,"w");
|
|
Vsetattr(dataID, (char *)name, type, (int32) length, sLink->targetPath);
|
|
Vdetach(dataID);
|
|
}
|
|
return NX_OK;
|
|
}
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
|
|
NXstatus NX4makenamedlink (NXhandle fid, CONSTCHAR* newname, NXlink* sLink)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 dataID, type = DFNT_CHAR8, length, dataType = NX_CHAR,
|
|
rank = 1, attType = NX_INT32;
|
|
int64_t iDim[1];
|
|
char name[] = "target";
|
|
int tags[2];
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
if (pFile->iCurrentVG == 0) { /* root level, can not link here */
|
|
return NX_ERROR;
|
|
}
|
|
|
|
tags[0] = sLink->iTag;
|
|
tags[1] = sLink->iRef;
|
|
|
|
length = strlen(sLink->targetPath);
|
|
if(sLink->iTag == DFTAG_SDG || sLink->iTag == DFTAG_NDG ||
|
|
sLink->iTag == DFTAG_SDS)
|
|
{
|
|
iDim[0] = 1;
|
|
NX4makedata64(fid,newname, dataType,rank,iDim);
|
|
NX4opendata(fid,newname);
|
|
NX4putattr(fid,"NAPIlink",tags, 2, attType);
|
|
NX4closedata(fid);
|
|
dataID = SDreftoindex(pFile->iSID,sLink->iRef);
|
|
dataID = SDselect(pFile->iSID,dataID);
|
|
SDsetattr(dataID,name,type,length,sLink->targetPath);
|
|
SDendaccess(dataID);
|
|
} else {
|
|
NX4makegroup(fid,newname,"NAPIlink");
|
|
NX4opengroup(fid,newname,"NAPIlink");
|
|
NX4putattr(fid,"NAPIlink",tags, 2, attType);
|
|
NX4closegroup(fid);
|
|
dataID = Vattach(pFile->iVID,sLink->iRef,"w");
|
|
Vsetattr(dataID, (char *)name, type, (int32) length, sLink->targetPath);
|
|
Vdetach(dataID);
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
NXstatus NX4printlink (NXhandle fid, NXlink* sLink)
|
|
{
|
|
NXIassert (fid);
|
|
printf("HDF4 link: iTag = %ld, iRef = %ld, target=\"%s\"\n", sLink->iTag, sLink->iRef, sLink->targetPath);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
NXstatus NX4flush(NXhandle *pHandle)
|
|
{
|
|
char *pFileName, *pCopy = NULL;
|
|
int access, dummy, iRet, i, iStack;
|
|
pNexusFile pFile = NULL;
|
|
NXaccess ac;
|
|
int *iRefs = NULL;
|
|
|
|
pFile = NXIassert(*pHandle);
|
|
|
|
/*
|
|
The HDF4-API does not support a flush. We help ourselves with
|
|
inquiring the name and access type of the file, closing it and
|
|
opening it again. This is also the reason why this needs a pointer
|
|
to the handle structure as the handle changes. The other thing we
|
|
do is to store the refs of all open vGroups in a temporary array
|
|
in order to recover the position in the vGroup hierarchy before the
|
|
flush.
|
|
*/
|
|
iRet = Hfidinquire(pFile->iVID,&pFileName,&access,&dummy);
|
|
if (iRet < 0) {
|
|
NXReportError(
|
|
"ERROR: Failed to inquire file name for HDF file");
|
|
return NX_ERROR;
|
|
}
|
|
if(pFile->iAccess[0] == 'r') {
|
|
ac = NXACC_READ;
|
|
}else if(pFile->iAccess[0] == 'w') {
|
|
ac = NXACC_RDWR;
|
|
} else {
|
|
NXReportError(
|
|
"ERROR: NX4flush failed to determine file access mode");
|
|
return NX_ERROR;
|
|
}
|
|
pCopy = (char *)malloc((strlen(pFileName)+10)*sizeof(char));
|
|
if(!pCopy) {
|
|
NXReportError(
|
|
"ERROR: Failed to allocate data for filename copy");
|
|
return NX_ERROR;
|
|
}
|
|
memset(pCopy,0,strlen(pFileName)+10);
|
|
strcpy(pCopy,pFileName);
|
|
|
|
/* get refs for recovering vGroup position */
|
|
iStack = 0;
|
|
if(pFile->iStackPtr > 0) {
|
|
iStack = pFile->iStackPtr + 1;
|
|
iRefs = (int *)malloc(iStack*sizeof(int));
|
|
if(!iRefs){
|
|
NXReportError(
|
|
"ERROR: Failed to allocate data for hierarchy copy");
|
|
return NX_ERROR;
|
|
}
|
|
for(i = 0; i < iStack; i++){
|
|
iRefs[i] = pFile->iStack[i].iVref;
|
|
}
|
|
}
|
|
|
|
iRet = NX4close(pHandle);
|
|
if(iRet != NX_OK) {
|
|
return iRet;
|
|
}
|
|
|
|
iRet = NX4open(pCopy, ac, pHandle);
|
|
free(pCopy);
|
|
|
|
/* return to position in vGroup hierarchy */
|
|
pFile = NXIassert(*pHandle);
|
|
if(iStack > 0){
|
|
pFile->iStackPtr = iStack - 1;
|
|
for(i = 0; i < iStack; i++){
|
|
pFile->iStack[i].iVref = iRefs[i];
|
|
}
|
|
free(iRefs);
|
|
pFile->iCurrentVG = Vattach(pFile->iVID,
|
|
pFile->iStack[pFile->iStackPtr].iVref,
|
|
pFile->iAccess);
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4getnextentry (NXhandle fid, NXname name, NXname nxclass, int *datatype)
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet, iStackPtr, iCurDir;
|
|
int32 iTemp, iD1, iD2, iA;
|
|
int32 iDim[H4_MAX_VAR_DIMS];
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
iStackPtr = pFile->iStackPtr;
|
|
iCurDir = pFile->iStack[pFile->iStackPtr].iCurDir;
|
|
|
|
/* first case to check for: no directory entry */
|
|
if (pFile->iStack[pFile->iStackPtr].iRefDir == NULL) {
|
|
iRet = NXIInitDir (pFile);
|
|
if (iRet < 0) {
|
|
NXReportError(
|
|
"ERROR: no memory to store directory info");
|
|
return NX_EOD;
|
|
}
|
|
}
|
|
|
|
/* Next case: end of directory */
|
|
if (iCurDir >= pFile->iStack[pFile->iStackPtr].iNDir) {
|
|
NXIKillDir (pFile);
|
|
return NX_EOD;
|
|
}
|
|
|
|
/* Next case: we have data! supply it and increment counter */
|
|
if (pFile->iCurrentVG == 0) { /* root level */
|
|
iTemp = Vattach (pFile->iVID,
|
|
pFile->iStack[iStackPtr].iRefDir[iCurDir], "r");
|
|
if (iTemp < 0) {
|
|
NXReportError( "ERROR: HDF cannot attach to Vgroup");
|
|
return NX_ERROR;
|
|
}
|
|
Vgetname (iTemp, name);
|
|
Vdetach (iTemp);
|
|
findNapiClass(pFile, pFile->iStack[pFile->iStackPtr].iRefDir[iCurDir], nxclass);
|
|
*datatype = DFTAG_VG;
|
|
pFile->iStack[pFile->iStackPtr].iCurDir++;
|
|
return NX_OK;
|
|
} else { /* in Vgroup */
|
|
if (pFile->iStack[iStackPtr].iTagDir[iCurDir] == DFTAG_VG) {/* Vgroup */
|
|
iTemp = Vattach (pFile->iVID,
|
|
pFile->iStack[iStackPtr].iRefDir[iCurDir], "r");
|
|
if (iTemp < 0) {
|
|
NXReportError( "ERROR: HDF cannot attach to Vgroup");
|
|
return NX_ERROR;
|
|
}
|
|
Vgetname (iTemp, name);
|
|
Vdetach(iTemp);
|
|
findNapiClass(pFile, pFile->iStack[pFile->iStackPtr].iRefDir[iCurDir], nxclass);
|
|
*datatype = DFTAG_VG;
|
|
pFile->iStack[pFile->iStackPtr].iCurDir++;
|
|
Vdetach (iTemp);
|
|
return NX_OK;
|
|
/* we are now writing using DFTAG_NDG, but need others for backward compatability */
|
|
} else if ((pFile->iStack[iStackPtr].iTagDir[iCurDir] == DFTAG_SDG) ||
|
|
(pFile->iStack[iStackPtr].iTagDir[iCurDir] == DFTAG_NDG) ||
|
|
(pFile->iStack[iStackPtr].iTagDir[iCurDir] == DFTAG_SDS)) {
|
|
iTemp = SDreftoindex (pFile->iSID,
|
|
pFile->iStack[iStackPtr].iRefDir[iCurDir]);
|
|
iTemp = SDselect (pFile->iSID, iTemp);
|
|
SDgetinfo (iTemp, name, &iA, iDim, &iD1, &iD2);
|
|
strcpy (nxclass, "SDS");
|
|
*datatype = iD1;
|
|
SDendaccess (iTemp);
|
|
pFile->iStack[pFile->iStackPtr].iCurDir++;
|
|
return NX_OK;
|
|
} else { /* unidentified */
|
|
strcpy (name, "UNKNOWN");
|
|
strcpy (nxclass, "UNKNOWN");
|
|
*datatype = pFile->iStack[iStackPtr].iTagDir[iCurDir];
|
|
pFile->iStack[pFile->iStackPtr].iCurDir++;
|
|
return NX_OK;
|
|
}
|
|
}
|
|
return NX_ERROR; /* not reached */
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4getdata (NXhandle fid, void *data)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iStart[H4_MAX_VAR_DIMS], iSize[H4_MAX_VAR_DIMS];
|
|
NXname pBuffer;
|
|
int32 iRank, iAtt, iType;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* check if there is an SDS open */
|
|
if (pFile->iCurrentSDS == 0) {
|
|
NXReportError( "ERROR: no SDS open");
|
|
return NX_ERROR;
|
|
}
|
|
/* first read dimension information */
|
|
memset (iStart, 0, H4_MAX_VAR_DIMS * sizeof (int32));
|
|
SDgetinfo (pFile->iCurrentSDS, pBuffer, &iRank, iSize, &iType, &iAtt);
|
|
/* actually read */
|
|
SDreaddata (pFile->iCurrentSDS, iStart, NULL, iSize, data);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus
|
|
NX4getinfo64 (NXhandle fid, int *rank, int64_t dimension[],
|
|
int *iType)
|
|
{
|
|
pNexusFile pFile;
|
|
NXname pBuffer;
|
|
int32 iAtt, myDim[H4_MAX_VAR_DIMS], i, iRank, mType;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* check if there is an SDS open */
|
|
if (pFile->iCurrentSDS == 0) {
|
|
NXReportError( "ERROR: no SDS open");
|
|
return NX_ERROR;
|
|
}
|
|
/* read information */
|
|
SDgetinfo (pFile->iCurrentSDS, pBuffer, &iRank, myDim,
|
|
&mType, &iAtt);
|
|
|
|
/* conversion to proper ints for the platform */
|
|
*iType = (int)mType;
|
|
*rank = (int)iRank;
|
|
for(i = 0; i < iRank; i++)
|
|
{
|
|
dimension[i] = (int)myDim[i];
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4getslab64 (NXhandle fid, void *data, const int64_t iStart[], const int64_t iSize[])
|
|
{
|
|
pNexusFile pFile;
|
|
int32 myStart[H4_MAX_VAR_DIMS], mySize[H4_MAX_VAR_DIMS];
|
|
int32 i, iRank, iType, iAtt;
|
|
NXname pBuffer;
|
|
|
|
pFile = NXIassert (fid);
|
|
|
|
/* check if there is an SDS open */
|
|
if (pFile->iCurrentSDS == 0) {
|
|
NXReportError( "ERROR: no SDS open");
|
|
return NX_ERROR;
|
|
}
|
|
|
|
SDgetinfo (pFile->iCurrentSDS, pBuffer,
|
|
&iRank, myStart, &iType, &iAtt);
|
|
for(i = 0; i < iRank; i++)
|
|
{
|
|
myStart[i] = (int32)iStart[i];
|
|
mySize[i] = (int32)iSize[i];
|
|
}
|
|
/* finally read */
|
|
SDreaddata (pFile->iCurrentSDS, myStart, NULL,
|
|
mySize, data);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX4getnextattr (NXhandle fileid, NXname pName,
|
|
int *iLength, int *iType)
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet;
|
|
int32 iPType, iCount, count;
|
|
|
|
pFile = NXIassert (fileid);
|
|
|
|
/* first check if we have to start a new attribute search */
|
|
if (pFile->iAtt.iNDir == 0) {
|
|
iRet = NXIInitAttDir (pFile);
|
|
if (iRet == NX_ERROR) {
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
/* are we done ? */
|
|
if (pFile->iAtt.iCurDir >= pFile->iAtt.iNDir) {
|
|
NXIKillAttDir (pFile);
|
|
return NX_EOD;
|
|
}
|
|
/* well, there must be data to copy */
|
|
if (pFile->iCurrentSDS == 0) {
|
|
if(pFile->iCurrentVG == 0) {
|
|
/* global attribute */
|
|
iRet = SDattrinfo (pFile->iSID, pFile->iAtt.iCurDir,
|
|
pName, &iPType, &iCount);
|
|
}else {
|
|
/* group attribute */
|
|
iRet = Vattrinfo(pFile->iCurrentVG, pFile->iAtt.iCurDir,
|
|
pName, &iPType, &iCount, &count);
|
|
}
|
|
} else {
|
|
iRet = SDattrinfo (pFile->iCurrentSDS, pFile->iAtt.iCurDir,
|
|
pName, &iPType, &iCount);
|
|
}
|
|
if (iRet < 0) {
|
|
NXReportError( "ERROR: HDF cannot read attribute info");
|
|
return NX_ERROR;
|
|
}
|
|
*iLength = iCount;
|
|
*iType = iPType;
|
|
pFile->iAtt.iCurDir++;
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4getattr (NXhandle fid, char *name, void *data, int* datalen, int* iType)
|
|
{
|
|
pNexusFile pFile;
|
|
int32 iNew, iType32, count;
|
|
void *pData = NULL;
|
|
int32 iLen, iRet;
|
|
int type;
|
|
char pBuffer[256];
|
|
NXname pNam;
|
|
|
|
type = *iType;
|
|
if (type == NX_CHAR)
|
|
{
|
|
type=DFNT_CHAR8;
|
|
}
|
|
else if (type == NX_INT8)
|
|
{
|
|
type=DFNT_INT8;
|
|
}
|
|
else if (type == NX_UINT8)
|
|
{
|
|
type=DFNT_UINT8;
|
|
}
|
|
else if (type == NX_INT16)
|
|
{
|
|
type=DFNT_INT16;
|
|
}
|
|
else if (type == NX_UINT16)
|
|
{
|
|
type=DFNT_UINT16;
|
|
}
|
|
else if (type == NX_INT32)
|
|
{
|
|
type=DFNT_INT32;
|
|
}
|
|
else if (type == NX_UINT32)
|
|
{
|
|
type=DFNT_UINT32;
|
|
}
|
|
else if (type == NX_FLOAT32)
|
|
{
|
|
type=DFNT_FLOAT32;
|
|
}
|
|
else if (type == NX_FLOAT64)
|
|
{
|
|
type=DFNT_FLOAT64;
|
|
}
|
|
*datalen = (*datalen) * DFKNTsize(type);
|
|
pFile = NXIassert (fid);
|
|
|
|
/* find attribute */
|
|
if (pFile->iCurrentSDS != 0) {
|
|
/* SDS attribute */
|
|
iNew = SDfindattr (pFile->iCurrentSDS, name);
|
|
} else {
|
|
if(pFile->iCurrentVG == 0){
|
|
/* global attribute */
|
|
iNew = SDfindattr (pFile->iSID, name);
|
|
} else {
|
|
/* group attribute */
|
|
iNew = Vfindattr(pFile->iCurrentVG, name);
|
|
}
|
|
}
|
|
if (iNew < 0) {
|
|
sprintf (pBuffer, "ERROR: attribute \"%s\" not found", name);
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
/* get more info, allocate temporary data space */
|
|
iType32 = (int32)type;
|
|
if (pFile->iCurrentSDS != 0) {
|
|
iRet = SDattrinfo (pFile->iCurrentSDS, iNew, pNam, &iType32, &iLen);
|
|
} else {
|
|
if(pFile->iCurrentVG == 0){
|
|
iRet = SDattrinfo (pFile->iSID, iNew, pNam, &iType32, &iLen);
|
|
} else {
|
|
iRet = Vattrinfo(pFile->iCurrentVG,iNew,pNam,&iType32,&count,
|
|
&iLen);
|
|
}
|
|
}
|
|
if (iRet < 0) {
|
|
sprintf (pBuffer, "ERROR: HDF could not read attribute info");
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
*iType = (int)iType32;
|
|
iLen = iLen * DFKNTsize (*iType);
|
|
if(*iType == NX_CHAR){
|
|
iLen += 1;
|
|
}
|
|
pData = (void *) malloc (iLen);
|
|
if (!pData) {
|
|
NXReportError( "ERROR: allocating memory in NXgetattr");
|
|
return NX_ERROR;
|
|
}
|
|
memset (pData, 0, iLen);
|
|
|
|
/* finally read the data */
|
|
if (pFile->iCurrentSDS != 0) {
|
|
iRet = SDreadattr (pFile->iCurrentSDS, iNew, pData);
|
|
} else {
|
|
if(pFile->iCurrentVG == 0){
|
|
iRet = SDreadattr (pFile->iSID, iNew, pData);
|
|
} else {
|
|
iRet = Vgetattr(pFile->iCurrentVG, iNew, pData);
|
|
}
|
|
}
|
|
if (iRet < 0) {
|
|
sprintf (pBuffer, "ERROR: HDF could not read attribute data");
|
|
NXReportError( pBuffer);
|
|
return NX_ERROR;
|
|
}
|
|
/* copy data to caller */
|
|
memset (data, 0, *datalen);
|
|
if ((*datalen <= iLen) &&
|
|
(*iType == DFNT_UINT8 || *iType == DFNT_CHAR8 || *iType == DFNT_UCHAR8)) {
|
|
iLen = *datalen - 1; /* this enforces NULL termination regardless of size of datalen */
|
|
}
|
|
memcpy (data, pData, iLen);
|
|
*datalen = iLen / DFKNTsize(*iType);
|
|
free (pData);
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4getattrinfo (NXhandle fid, int *iN)
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet;
|
|
int32 iData, iAtt, iRank, iType;
|
|
int32 iDim[H4_MAX_VAR_DIMS];
|
|
NXname pNam;
|
|
|
|
pFile = NXIassert (fid);
|
|
if (pFile->iCurrentSDS != 0) { /* SDS level */
|
|
iRet = SDgetinfo (pFile->iCurrentSDS, pNam, &iRank, iDim, &iType,
|
|
&iAtt);
|
|
} else {
|
|
if(pFile->iCurrentVG == 0){
|
|
/* global level */
|
|
iRet = SDfileinfo (pFile->iSID, &iData, &iAtt);
|
|
} else {
|
|
iRet = Vnattrs(pFile->iCurrentVG);
|
|
iAtt = iRet;
|
|
}
|
|
}
|
|
if (iRet < 0) {
|
|
NXReportError( "NX_ERROR: HDF cannot read attribute numbers");
|
|
*iN = 0;
|
|
return NX_ERROR;
|
|
}
|
|
*iN = iAtt;
|
|
return NX_OK;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus NX4getgroupID (NXhandle fileid, NXlink* sRes)
|
|
{
|
|
pNexusFile pFile;
|
|
|
|
pFile = NXIassert (fileid);
|
|
|
|
if (pFile->iCurrentVG == 0) {
|
|
sRes->iTag = NX_ERROR;
|
|
return NX_ERROR;
|
|
} else {
|
|
sRes->iTag = DFTAG_VG;
|
|
sRes->iRef = VQueryref(pFile->iCurrentVG);
|
|
NXIbuildPath(pFile,sRes->targetPath,1024);
|
|
return NX_OK;
|
|
}
|
|
/* not reached */
|
|
sRes->iTag = NX_ERROR;
|
|
return NX_ERROR;
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
NXstatus
|
|
NX4getgroupinfo (NXhandle fid, int *iN, NXname pName, NXname pClass)
|
|
{
|
|
pNexusFile pFile;
|
|
|
|
pFile = NXIassert (fid);
|
|
/* check if there is a group open */
|
|
if (pFile->iCurrentVG == 0) {
|
|
*iN = Vlone (pFile->iVID, NULL, 0);
|
|
strcpy (pName, "root");
|
|
strcpy (pClass, "NXroot");
|
|
}
|
|
else {
|
|
*iN = Vntagrefs (pFile->iCurrentVG);
|
|
Vgetname (pFile->iCurrentVG, pName);
|
|
Vgetclass (pFile->iCurrentVG, pClass);
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------- */
|
|
|
|
NXstatus NX4sameID (NXhandle fileid, NXlink* pFirstID, NXlink* pSecondID)
|
|
{
|
|
NXIassert (fileid);
|
|
if ((pFirstID->iTag == pSecondID->iTag) & (pFirstID->iRef == pSecondID->iRef)) {
|
|
return NX_OK;
|
|
} else {
|
|
return NX_ERROR;
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4initattrdir (NXhandle fid)
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet;
|
|
|
|
pFile = NXIassert (fid);
|
|
NXIKillAttDir (pFile);
|
|
iRet = NXIInitAttDir (pFile);
|
|
if (iRet == NX_ERROR)
|
|
return NX_ERROR;
|
|
return NX_OK;
|
|
}
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
NXstatus NX4initgroupdir (NXhandle fid)
|
|
{
|
|
pNexusFile pFile;
|
|
int iRet;
|
|
|
|
pFile = NXIassert (fid);
|
|
NXIKillDir (pFile);
|
|
iRet = NXIInitDir (pFile);
|
|
if (iRet < 0) {
|
|
NXReportError("NX_ERROR: no memory to store directory info");
|
|
return NX_EOD;
|
|
}
|
|
return NX_OK;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
void NX4assignFunctions(pNexusFunction fHandle)
|
|
{
|
|
fHandle->nxclose=NX4close;
|
|
fHandle->nxreopen=NULL;
|
|
fHandle->nxflush=NX4flush;
|
|
fHandle->nxmakegroup=NX4makegroup;
|
|
fHandle->nxopengroup=NX4opengroup;
|
|
fHandle->nxclosegroup=NX4closegroup;
|
|
fHandle->nxmakedata64=NX4makedata64;
|
|
fHandle->nxcompmakedata64=NX4compmakedata64;
|
|
fHandle->nxcompress=NX4compress;
|
|
fHandle->nxopendata=NX4opendata;
|
|
fHandle->nxclosedata=NX4closedata;
|
|
fHandle->nxputdata=NX4putdata;
|
|
fHandle->nxputattr=NX4putattr;
|
|
fHandle->nxputslab64=NX4putslab64;
|
|
fHandle->nxgetdataID=NX4getdataID;
|
|
fHandle->nxmakelink=NX4makelink;
|
|
fHandle->nxmakenamedlink=NX4makenamedlink;
|
|
fHandle->nxgetdata=NX4getdata;
|
|
fHandle->nxgetinfo64=NX4getinfo64;
|
|
fHandle->nxgetnextentry=NX4getnextentry;
|
|
fHandle->nxgetslab64=NX4getslab64;
|
|
fHandle->nxgetnextattr=NX4getnextattr;
|
|
fHandle->nxgetattr=NX4getattr;
|
|
fHandle->nxgetattrinfo=NX4getattrinfo;
|
|
fHandle->nxgetgroupID=NX4getgroupID;
|
|
fHandle->nxgetgroupinfo=NX4getgroupinfo;
|
|
fHandle->nxsameID=NX4sameID;
|
|
fHandle->nxinitgroupdir=NX4initgroupdir;
|
|
fHandle->nxinitattrdir=NX4initattrdir;
|
|
fHandle->nxprintlink=NX4printlink;
|
|
fHandle->nxnativeexternallink=NULL;
|
|
}
|
|
|
|
#endif /*HDF4*/
|