JNIEXPORT void JNICALL
Java_hdf_hdflib_HDFLibrary_Vend
(JNIEnv *env, jclass clss, jlong fid)
{
HFILEID id = (HFILEID)fid;
Vend(id);
}
static void
test_vgisinternal()
{
int32 fid, vgroup_id;
intn is_internal = FALSE;
int32 vref = -1;
intn ii, status;
char testfile[H4_MAX_NC_NAME] = "";
char internal_array2[2] = {TRUE, TRUE};
intn num_errs = 0; /* number of errors so far */
/* Use a GR file to test Vgisinternal on internal vgroups */
/* The file GR_FILE is an existing file in the test_files directory,
make_datafilename builds the file name with correct path */
if (make_datafilename(GR_FILE, testfile, H4_MAX_NC_NAME) != FAIL)
{
/* Open the old GR file and initialize the V interface */
fid = Hopen(testfile, DFACC_READ, 0);
CHECK_VOID(fid, FAIL, "Hopen: grtdfui83.hdf");
status = Vstart(fid);
CHECK_VOID(status, FAIL, "Vstart");
ii = 0;
while ((vref = Vgetid(fid, vref)) != FAIL)
{ /* until no more vgroups */
vgroup_id = Vattach(fid, vref, "r"); /* attach to vgroup */
/* Test that the current vgroup is or is not internal as specified
in the array internal_array2 */
is_internal = Vgisinternal(vgroup_id);
CHECK_VOID(is_internal, FAIL, "Vgisinternal");
VERIFY_VOID(is_internal, internal_array2[ii], "Vgisinternal");
status = Vdetach(vgroup_id);
CHECK_VOID(status, FAIL, "Vdetach");
ii++; /* increment vgroup index */
}
/* Terminate access to the V interface and close the file */
status = Vend(fid);
CHECK_VOID(status, FAIL, "Vend");
status = Hclose(fid);
CHECK_VOID(status, FAIL, "Hclose");
}
else
{
fprintf(stderr, "ERROR>>> Unable to make filename for %s\n", GR_FILE);
H4_FAILED()
}
} /* test_vgisinternal */
int main( )
{
/************************* Variable declaration **************************/
intn status_n; /* returned status for functions returning an intn */
int32 status_32, /* returned status for functions returning an int32 */
file_id, vdata_id, vdata_ref,
index = 0; /* index of the vdata in the file - manually kept */
int8 found_fields; /* TRUE if the specified fields exist in the vdata */
/********************** End of variable declaration **********************/
/*
* Open the HDF file for reading.
*/
file_id = Hopen (FILE_NAME, DFACC_READ, 0);
/*
* Initialize the VS interface.
*/
status_n = Vstart (file_id);
/*
* Set the reference number to -1 to start the search from
* the beginning of file.
*/
vdata_ref = -1;
/*
* Assume that the specified fields are not found in the current vdata.
*/
found_fields = FALSE;
/*
* Use VSgetid to obtain each vdata by its reference number then
* attach to the vdata and search for the fields. The loop
* terminates when the last vdata is reached or when a vdata which
* contains the fields listed in SEARCHED_FIELDS is found.
*/
while ((vdata_ref = VSgetid (file_id, vdata_ref)) != FAIL)
{
vdata_id = VSattach (file_id, vdata_ref, "r");
if ((status_n = VSfexist (vdata_id, SEARCHED_FIELDS)) != FAIL)
{
found_fields = TRUE;
break;
}
/*
* Detach from the current vdata before continuing searching.
*/
status_32 = VSdetach (vdata_id);
index++; /* advance the index by 1 for the next vdata */
}
/*
* Print the index of the vdata containing the fields or a "not found"
* message if no such vdata is found. Also detach from the vdata found.
*/
if (!found_fields)
printf ("Fields Position and Temperature were not found.\n");
else
{
printf
("Fields Position and Temperature found in the vdata at position %d\n",
index);
status_32 = VSdetach (vdata_id);
}
/*
* Terminate access to the VS interface and close the HDF file.
*/
status_n = Vend (file_id);
status_32 = Hclose (file_id);
return 0;
}
static int do_groups(void)
{
int32 vg0_id, /* vgroup identifier */
vg1_id, /* vgroup identifier */
vg2_id, /* vgroup identifier */
file1_id; /* HDF file identifier */
/* create a HDF file */
if ((file1_id = Hopen (FILE7_NAME, DFACC_CREATE, (int16)0))<0)
{
printf("Error: Could not create file <%s>\n",FILE7_NAME);
return FAIL;
}
/* initialize the V interface */
if (Vstart (file1_id)==FAIL)
{
printf( "Could not start VG\n");
return FAIL;
}
/* create a vgroup */
vg0_id = Vattach (file1_id, -1, "w");
if (Vsetname (vg0_id, "g0")==FAIL)
{
printf( "Could not name group\n");
goto out;
}
/* create the second vgroup */
vg1_id = Vattach (file1_id, -1, "w");
if (Vsetname (vg1_id, "g1")==FAIL)
{
printf( "Could not name group\n");
goto out;
}
/* create the third vgroup */
vg2_id = Vattach (file1_id, -1, "w");
if (Vsetname (vg2_id, "g1.1")==FAIL)
{
printf( "Could not name group\n");
goto out;
}
if (Vinsert (vg0_id, vg1_id)==FAIL)
{
printf( "Could not insert VG\n");
goto out;
}
if (Vinsert (vg0_id, vg2_id)==FAIL)
{
printf( "Could not insert VG\n");
goto out;
}
if (Vinsert (vg1_id, vg2_id)==FAIL)
{
printf( "Could not insert VG\n");
goto out;
}
if (Vinsert (vg2_id, vg1_id)==FAIL)
{
printf( "Could not insert VG\n");
goto out;
}
/* terminate access to the vgroup */
if (Vdetach (vg0_id)==FAIL)
{
printf( "Could not close group\n");
goto out;
}
/* terminate access to the vgroup */
if (Vdetach (vg1_id)==FAIL)
{
printf( "Could not close group\n");
goto out;
}
/* terminate access to the vgroup */
if (Vdetach (vg2_id)==FAIL)
{
printf( "Could not close group\n");
goto out;
}
/* terminate access to the V interface */
if (Vend (file1_id)==FAIL)
{
printf( "Could not end VG\n");
goto out;
}
/* close the HDF file */
if (Hclose (file1_id)==FAIL)
{
printf( "Could not close file\n");
return FAIL;
}
return SUCCEED;
out:
printf("Error...Exiting...\n");
return FAIL;
}
int main(void)
{
int32 sd1_id; /* SD interface identifier */
int32 sd2_id; /* SD interface identifier */
int32 sds1_id; /* SDS identifier */
int32 sds2_id; /* SDS identifier */
int32 dim_sizes[2]; /* sizes of the SDS dimensions */
int32 start[2]; /* start location to write */
int32 edges[2]; /* number of elements to write */
int32 n_values;
int32 buf1a[Y_LENGTH][X_LENGTH] = {{1,1},{1,1},{5,6}};
int32 buf1b[Y_LENGTH][X_LENGTH] = {{1,2},{3,4},{5,6}};
/* percent test: compare divide by zero, both zero */
int32 buf2a[Y_LENGTH][X_LENGTH] = {{100,100},{100,0},{0,100}};
int32 buf2b[Y_LENGTH][X_LENGTH] = {{120,80},{0,100},{0,50}};
/* global attributes */
char8 bufga1[] = "Storm_track_data1";
char8 bufga2[] = "Storm_track_data2";
float32 bufa1[2] = {1., 1.};
float32 bufa2[2] = {1., 2.};
/*vdata*/
int32 file1_id;
int32 file2_id;
int32 vdata1_id;
int32 vdata2_id;
char8 vdata1_buf1 [N_RECORDS_1] = {'V', 'D', 'A', 'T', 'A'};
char8 vdata1_buf2 [N_RECORDS_1] = {'X', 'D', 'A', 'T', 'A'};
int32 vdata2_buf1 [N_RECORDS_2][ORDER_2] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
int32 vdata2_buf2 [N_RECORDS_2][ORDER_2] = {{1, 1, 1, 1}, {5, 6, 7, 8}};
float32 vdata3_buf1[N_RECORDS_2][N_VALS_PER_REC]={{1,2,3,4,5,6},{7,8,9,10,11,12}};
float32 vdata3_buf2[N_RECORDS_2][N_VALS_PER_REC]={{1,1,1,1,1,1},{7,8,9,10,11,12}};
/* Define the location and size of the data to be written to the data set*/
start[0] = 0;
start[1] = 0;
edges[0] = Y_LENGTH;
edges[1] = X_LENGTH;
/* Define the dimensions of the array to be created */
dim_sizes[0] = Y_LENGTH;
dim_sizes[1] = X_LENGTH;
/*-------------------------------------------------------------------------
* SD data
*-------------------------------------------------------------------------
*/
/* Create the files and initialize the SD interface */
if ((sd1_id = SDstart (FILE1_NAME, DFACC_CREATE))==FAIL)
goto error;
if ((sd2_id = SDstart (FILE2_NAME, DFACC_CREATE))==FAIL)
goto error;
/* Set a global attribute */
n_values = sizeof(bufga1);
if ( SDsetattr (sd1_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values, (VOIDP)bufga1)==FAIL)
goto error;
if ( SDsetattr (sd2_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values, (VOIDP)bufga2)==FAIL)
goto error;
/* Create the data sets */
if ((sds1_id = SDcreate (sd1_id, "dset1", DFNT_INT32, RANK, dim_sizes))==FAIL)
goto error;
if ((sds2_id = SDcreate (sd2_id, "dset1", DFNT_INT32, RANK, dim_sizes))==FAIL)
goto error;
/* Assign attribute */
n_values = 2;
if ( SDsetattr (sds1_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values, (VOIDP)bufa1)==FAIL)
goto error;
if ( SDsetattr (sds2_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values, (VOIDP)bufa2)==FAIL)
goto error;
/* Write the stored data to the data set */
if ( SDwritedata (sds1_id, start, NULL, edges, (VOIDP)buf1a)==FAIL)
goto error;
if ( SDwritedata (sds2_id, start, NULL, edges, (VOIDP)buf1b)==FAIL)
goto error;
/* Terminate access to the data set */
if ( SDendaccess (sds1_id)==FAIL)
goto error;
if ( SDendaccess (sds2_id)==FAIL)
goto error;
/* Create another data set */
if (( sds1_id = SDcreate (sd1_id, "dset2", DFNT_INT32, RANK, dim_sizes))==FAIL)
goto error;
if (( sds2_id = SDcreate (sd2_id, "dset2", DFNT_INT32, RANK, dim_sizes))==FAIL)
goto error;
if ( SDwritedata (sds1_id, start, NULL, edges, (VOIDP)buf1a)==FAIL)
goto error;
if ( SDwritedata (sds2_id, start, NULL, edges, (VOIDP)buf1b)==FAIL)
goto error;
if ( SDendaccess (sds1_id)==FAIL)
goto error;
if ( SDendaccess (sds2_id)==FAIL)
goto error;
/* data sets for -p test */
if (( sds1_id = SDcreate (sd1_id, "dset3", DFNT_INT32, RANK, dim_sizes))==FAIL)
goto error;
if (( sds2_id = SDcreate (sd2_id, "dset3", DFNT_INT32, RANK, dim_sizes))==FAIL)
goto error;
if ( SDwritedata (sds1_id, start, NULL, edges, (VOIDP)buf2a)==FAIL)
goto error;
if ( SDwritedata (sds2_id, start, NULL, edges, (VOIDP)buf2b)==FAIL)
goto error;
if ( SDendaccess (sds1_id)==FAIL)
goto error;
if ( SDendaccess (sds2_id)==FAIL)
goto error;
/*-------------------------------------------------------------------------
* end SD
*-------------------------------------------------------------------------
*/
/* Terminate access to the SD interface and close the file */
if ( SDend (sd1_id)==FAIL)
goto error;
if ( SDend (sd2_id)==FAIL)
goto error;
/*-------------------------------------------------------------------------
* VD data
*-------------------------------------------------------------------------
*/
/* Open the HDF file for writing */
if ((file1_id = Hopen (FILE1_NAME, DFACC_WRITE, 0))==FAIL)
goto error;
if ((file2_id = Hopen (FILE2_NAME, DFACC_WRITE, 0))==FAIL)
goto error;
/* Initialize the VS interface */
if ( Vstart (file1_id)==FAIL)
goto error;
if ( Vstart (file2_id)==FAIL)
goto error;
/*-------------------------------------------------------------------------
* VD data one field
*-------------------------------------------------------------------------
*/
/* Create the first vdata and populate it with data from vdata1_buf */
if (VHstoredata (file1_id, FIELD1_NAME, (uint8 *)vdata1_buf1,
N_RECORDS_1, DFNT_CHAR8, VDATA1_NAME, CLASS1_NAME)==FAIL)
goto error;
if (VHstoredata (file2_id, FIELD1_NAME, (uint8 *)vdata1_buf2,
N_RECORDS_1, DFNT_CHAR8, VDATA1_NAME, CLASS1_NAME)==FAIL)
goto error;
/*-------------------------------------------------------------------------
* VD data one field, order 4
*-------------------------------------------------------------------------
*/
/* Create the second vdata and populate it with data from vdata2_buf */
if ( VHstoredatam (file1_id, FIELD2_NAME, (uint8 *)vdata2_buf1,
N_RECORDS_2, DFNT_INT32, VDATA2_NAME, CLASS2_NAME, ORDER_2)==FAIL)
goto error;
if ( VHstoredatam (file2_id, FIELD2_NAME, (uint8 *)vdata2_buf2,
N_RECORDS_2, DFNT_INT32, VDATA2_NAME, CLASS2_NAME, ORDER_2)==FAIL)
goto error;
/*-------------------------------------------------------------------------
* VD data several fields
*-------------------------------------------------------------------------
*/
/* Create a new vdata */
if ((vdata1_id = VSattach (file1_id, -1, "w"))==FAIL)
goto error;
if ((vdata2_id = VSattach (file2_id, -1, "w"))==FAIL)
goto error;
/* Set name and class name of the vdata */
if ( VSsetname (vdata1_id, VDATA3_NAME)==FAIL)
goto error;
if ( VSsetclass (vdata1_id, CLASS3_NAME)==FAIL)
goto error;
if ( VSsetname (vdata2_id, VDATA3_NAME)==FAIL)
goto error;
if ( VSsetclass (vdata2_id, CLASS3_NAME)==FAIL)
goto error;
/* Define fields */
if ( VSfdefine (vdata1_id, FIELD3_NAME1, DFNT_FLOAT32, ORDER3_1 )==FAIL)
goto error;
if ( VSfdefine (vdata1_id, FIELD3_NAME2, DFNT_FLOAT32, ORDER3_2 )==FAIL)
goto error;
if ( VSfdefine (vdata1_id, FIELD3_NAME3, DFNT_FLOAT32, ORDER3_3 )==FAIL)
goto error;
if ( VSsetfields (vdata1_id, FIELDNAME3_LIST )==FAIL)
goto error;
if ( VSfdefine (vdata2_id, FIELD3_NAME1, DFNT_FLOAT32, ORDER3_1 )==FAIL)
goto error;
if ( VSfdefine (vdata2_id, FIELD3_NAME2, DFNT_FLOAT32, ORDER3_2 )==FAIL)
goto error;
if ( VSfdefine (vdata2_id, FIELD3_NAME3, DFNT_FLOAT32, ORDER3_3 )==FAIL)
goto error;
if ( VSsetfields (vdata2_id, FIELDNAME3_LIST)==FAIL)
goto error;
/* Write the data with full interlacing mode */
if ( VSwrite (vdata1_id, (uint8 *)vdata3_buf1, N_RECORDS_2, FULL_INTERLACE)==FAIL)
goto error;
if ( VSwrite (vdata2_id, (uint8 *)vdata3_buf2, N_RECORDS_2, FULL_INTERLACE)==FAIL)
goto error;
if ( VSdetach (vdata1_id)==FAIL)
goto error;
if ( VSdetach (vdata2_id)==FAIL)
goto error;
/*-------------------------------------------------------------------------
* end VD data
*-------------------------------------------------------------------------
*/
/* Terminate access to the VS interface and close the HDF file */
if ( Vend (file1_id)==FAIL)
goto error;
if ( Vend (file2_id)==FAIL)
goto error;
if ( Hclose (file1_id)==FAIL)
goto error;
if ( Hclose (file2_id)==FAIL)
goto error;
/*-------------------------------------------------------------------------
* write 2 big files for hyperslab reading
*-------------------------------------------------------------------------
*/
if (do_big_file()==FAIL)
goto error;
/*-------------------------------------------------------------------------
* groups
*-------------------------------------------------------------------------
*/
if (do_groups()==FAIL)
goto error;
return 0;
error:
printf("Error...Exiting...\n");
return 1;
}
int list_vg(int32 infile_id,
int32 outfile_id,
int32 sd_id,
int32 sd_out,
int32 gr_id,
int32 gr_out,
list_table_t *list_tbl,
dim_table_t *td1,
dim_table_t *td2,
options_t *options)
{
int32 vg_id; /* vgroup identifier */
int32 nlones = 0; /* number of lone vgroups */
int32 ntagrefs; /* number of tag/ref pairs in a vgroup */
int32 *ref_array=NULL;/* buffer to hold the ref numbers of lone vgroups */
int32 *tags=NULL; /* buffer to hold the tag numbers of vgroups */
int32 *refs=NULL; /* buffer to hold the ref numbers of vgroups */
int32 vgroup_id_out=0;/* vgroup identifier */
int32 tag_vg;
int32 ref_vg;
char *vg_name;
char *vg_class;
uint16 name_len;
int32 i;
/*-------------------------------------------------------------------------
* initialize the V interface
*-------------------------------------------------------------------------
*/
if (Vstart(infile_id) == FAIL)
{
return FAIL;
}
if (options->trip==1)
{
if (Vstart(outfile_id) == FAIL)
{
return FAIL;
}
}
/*-------------------------------------------------------------------------
* get and print the names and class names of all the lone vgroups.
* first, call Vlone with nlones set to 0 to get the number of
* lone vgroups in the file, but not to get their reference numbers.
*-------------------------------------------------------------------------
*/
nlones = Vlone (infile_id, NULL, nlones );
if (nlones > 0)
{
/*
* use the nlones returned to allocate sufficient space for the
* buffer ref_array to hold the reference numbers of all lone vgroups,
*/
ref_array = (int32 *) malloc(sizeof(int32) * nlones);
/*
* and call Vlone again to retrieve the reference numbers into
* the buffer ref_array.
*/
nlones = Vlone (infile_id, ref_array, nlones);
/*
* iterate tru each lone vgroup.
*/
for (i = 0; i < nlones; i++)
{
int32 ref = ref_array[i];
uint16 name_len;
/*
* attach to the current vgroup then get its
* name and class. note: the current vgroup must be detached before
* moving to the next.
*/
if ((vg_id = Vattach (infile_id, ref, "r"))==FAIL)
{
printf("Error: Could not attach group with ref <%d>\n", ref);
goto out;
}
/* Get vgroup's name */
if (Vgetnamelen(vg_id, &name_len)==FAIL)
{
printf("Error: Could not get name length for group with ref <%d>\n", ref);
goto out;
}
vg_name = (char *) HDmalloc(sizeof(char) * (name_len+1));
if (Vgetname (vg_id, vg_name)==FAIL)
{
printf( "Could not get name for group\n");
goto out;
}
/* Get vgroup's class name */
if (Vgetclassnamelen(vg_id, &name_len)==FAIL)
{
printf("Error: Could not get name length for group with ref <%d>\n", ref);
goto out;
}
vg_class = (char *) HDmalloc(sizeof(char) * (name_len+1));
if (Vgetclass (vg_id, vg_class)==FAIL)
{
printf( "Could not get class for group\n");
goto out;
}
/* ignore reserved HDF groups/vdatas */
if( is_reserved(vg_class))
{
if (Vdetach (vg_id)==FAIL)
{
printf( "Could not detach group\n");
goto out;
}
continue;
}
if(strcmp(vg_name,GR_NAME)==0)
{
if (Vdetach (vg_id)==FAIL)
{
printf( "Could not detach group\n");
goto out;
}
continue;
}
/* get ref, tag */
if ((ref_vg = VQueryref(vg_id))==FAIL)
{
printf( "Failed to get ref for <%s>\n", vg_name);
goto out;
}
if ((tag_vg = VQuerytag(vg_id))==FAIL)
{
printf( "Failed to get tag for <%s>\n", vg_name);
goto out;
}
/*-------------------------------------------------------------------------
* add object to table
*-------------------------------------------------------------------------
*/
list_table_add(list_tbl,tag_vg,ref_vg,vg_name);
if (options->verbose)
printf(PFORMAT,"","","",vg_name);
if (options->trip==1)
{
/*
* create the group in the output file. the vgroup reference number is set
* to -1 for creating and the access mode is "w" for writing
*/
vgroup_id_out = Vattach (outfile_id, -1, "w");
if (Vsetname (vgroup_id_out, vg_name)==FAIL)
{
printf("Error: Could not create group <%s>\n", vg_name);
goto out;
}
if (Vsetclass (vgroup_id_out, vg_class)==FAIL)
{
printf("Error: Could not create group <%s>\n", vg_name);
goto out;
}
if (copy_vgroup_attrs(vg_id,vgroup_id_out,vg_name,options)<0)
goto out;
if (copy_vg_an(infile_id,outfile_id,vg_id,vgroup_id_out,vg_name,options)<0)
goto out;
}
/* insert objects for this group */
ntagrefs = Vntagrefs(vg_id);
if ( ntagrefs > 0 )
{
tags = (int32 *) malloc(sizeof(int32) * ntagrefs);
refs = (int32 *) malloc(sizeof(int32) * ntagrefs);
if (Vgettagrefs(vg_id, tags, refs, ntagrefs)<0)
goto out;
if (vgroup_insert(infile_id,
outfile_id,
sd_id,
sd_out,
gr_id,
gr_out,
vgroup_id_out,
vg_name,
tags,
refs,
ntagrefs,
list_tbl,
td1,
td2,
options)<0) {
goto out;
}
free (tags);
tags=NULL;
free (refs);
refs=NULL;
}
if(Vdetach (vg_id)==FAIL)
{
printf("Error: Could not detach group <%s>\n", vg_name);
goto out;
}
if (options->trip==1)
{
if (Vdetach (vgroup_id_out)==FAIL)
{
printf("Error: Could not detach group <%s>\n", vg_name);
goto out;
}
}
free (vg_name);
} /* for nlones */
/* free the space allocated */
if (ref_array!=NULL)
free (ref_array);
} /* if nlones */
/*-------------------------------------------------------------------------
* terminate access to the V interface
*-------------------------------------------------------------------------
*/
if (Vend (infile_id)==FAIL)
{
printf("Error: Could not end group interface in <%s>\n", vg_name);
return FAIL;
}
if (options->trip==1)
{
if (Vend (outfile_id)==FAIL){
printf("Error: Could not end group interface in <%s>\n", vg_name);
return FAIL;
}
}
return SUCCEED;
out:
Vend (infile_id);
if (options->trip==1)
Vend (outfile_id);
/* free the space allocated */
if (ref_array!=NULL)
free (ref_array);
if (tags!=NULL)
free (tags);
if (refs!=NULL)
free (refs);
return FAIL;
}
int list_vs(int32 infile_id,
int32 outfile_id,
list_table_t *list_tbl,
options_t *options)
{
int32 nlones = 0, /* number of lone vdatas */
*ref_array=NULL, /* buffer to hold the ref numbers of lone vdatas */
ref; /* temporary ref number */
int i;
/*-------------------------------------------------------------------------
* initialize the V interface
*-------------------------------------------------------------------------
*/
if (Vstart(infile_id) == FAIL)
{
return FAIL;
}
if (options->trip==1)
{
if (Vstart(outfile_id) == FAIL)
{
return FAIL;
}
}
/*-------------------------------------------------------------------------
* get the names and class names of all the lone vdatas
* first, call Vlone with nlones set to 0 to get the number of lone vdatas
* in the file
*
*-------------------------------------------------------------------------
*/
nlones = VSlone (infile_id, NULL, nlones );
if (nlones > 0)
{
/*
* use the nlones returned to allocate sufficient space for the
* buffer ref_array to hold the reference numbers of all lone vgroups,
*/
ref_array = (int32 *) malloc(sizeof(int32) * nlones);
/*
* and call VSlone again to retrieve the reference numbers into
* the buffer ref_array.
*/
nlones = VSlone (infile_id, ref_array, nlones);
/*
* iterate tru each lone vdata.
*/
for (i = 0; i < nlones; i++)
{
/*
* attach to the current vdata then get its
* name and class. note: the current vdata must be detached before
* moving to the next.
*/
ref = ref_array[i];
/* check if already inserted in Vgroup, search with VS tag */
if ( list_table_search(list_tbl,DFTAG_VH,ref)>=0 )
{
continue;
}
/* copy VS */
if (copy_vs(infile_id,outfile_id,DFTAG_VH,ref,0,NULL,options,list_tbl,1)<0)
{
goto out;
}
} /* for */
/* free the space allocated */
if (ref_array)
{
free (ref_array);
ref_array = NULL;
}
} /* if */
/*-------------------------------------------------------------------------
* terminate access to the V interface
*-------------------------------------------------------------------------
*/
if (Vend (infile_id)==FAIL)
{
printf("Error: Could not end Vdata interface\n");
return FAIL;
}
if (options->trip==1)
{
if (Vend (outfile_id)==FAIL){
printf("Error: Could not end Vdata interface\n");
return FAIL;
}
}
return SUCCEED;
out:
Vend (infile_id);
if (options->trip==1)
Vend (outfile_id);
/* free the space allocated */
if (ref_array!=NULL)
free (ref_array);
return FAIL;
}
void main(void)
{
char vdata_name[MAX_NC_NAME], vdata_class[MAX_NC_NAME];
char fields[60];
int32 file_id, vdata_id, istat;
int32 n_records, interlace, vdata_size, vdata_ref;
int bufsz = (2 * sizeof(float32) + sizeof(char) \
+ sizeof(int16)) * NRECORDS;
int i;
uint8 databuf[((2 * sizeof(float32)) + sizeof(char) \
+ sizeof(int16)) * NRECORDS];
VOIDP fldbufptrs[4];
float32 itemp[NRECORDS], ispeed[NRECORDS];
int16 iheight[NRECORDS];
char idents[NRECORDS];
/* Open the HDF file. */
file_id = Hopen("VD_Ex4.hdf", DFACC_READ, 0);
/* Initialize the Vset interface. */
istat = Vstart(file_id);
/*
* Get the reference number for the first Vdata in
* the file.
*/
vdata_ref = -1;
vdata_ref = VSgetid(file_id, vdata_ref);
/* Attach to the first Vdata in read mode. */
vdata_id = VSattach(file_id, vdata_ref, "r");
for (i=0; i<60; i++)
fields[i] = '\0';
/* Get the list of field names. */
istat =VSinquire(vdata_id, &n_records, &interlace,
fields, &vdata_size, vdata_name);
printf("files: %s, n_records: %d, vdata_size: %d\n",
fields, n_records, vdata_size);
/* Get the class. */
istat = VSgetclass(vdata_id, vdata_class);
/* Determine the fields that will be read. */
istat = VSsetfields(vdata_id, fields);
/* Print the Vdata information. */
printf("Current Vdata name: %s \nCurrent Vdata class: %s.\n",
vdata_name, vdata_class);
/* Read the data. */
istat = VSread(vdata_id, (VOIDP)databuf, n_records,
FULL_INTERLACE);
/* set fldbufptrs and unpack field values */
fldbufptrs[0] = &idents[0];
fldbufptrs[1] = &ispeed[0];
fldbufptrs[2] = &iheight[0];
fldbufptrs[3] = &itemp[0];
istat = VSfpack(vdata_id, _HDF_VSUNPACK, fields, databuf,
bufsz, n_records, "Ident,Speed,Height,Temp",
fldbufptrs);
printf(" Temp Height Speed Ident\n");
for (i=0; i < n_records; i++) {
printf(" %6.2f %6d %6.2f %c\n",
itemp[i],iheight[i],ispeed[i],idents[i]);
}
/* Detach from the Vdata, close the interface and the file. */
istat = VSdetach(vdata_id);
istat = Vend(file_id);
istat = Hclose(file_id);
}
static void
test_vglongnames(void)
{
int32 file_id; /* File ID */
int32 vg1; /* Vdata ID */
int32 ref; /* Vdata ref */
uint16 name_len; /* Length of a vgroup's name or class name */
char *vgname, *vgclass;
intn is_internal;
int32 status; /* Status values from routines */
/* Open the HDF file. */
file_id = Hopen(LONGNAMES, DFACC_CREATE, 0);
CHECK_VOID(file_id,FAIL,"Hopen");
/* Initialize HDF for subsequent vgroup/vdata access. */
status = Vstart(file_id);
CHECK_VOID(status,FAIL,"Vstart");
/* Create a new vgroup. */
vg1 = Vattach(file_id, -1, "w");
CHECK_VOID(vg1,FAIL,"VSattach");
status=Vsetname(vg1, VG_LONGNAME);
CHECK_VOID(status,FAIL,"VSsetname");
status=Vsetclass(vg1, VG_LONGCLASS);
CHECK_VOID(status,FAIL,"VSsetname");
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
/* Create another vgroup of the same class. */
vg1 = Vattach(file_id, -1, "w");
CHECK_VOID(vg1,FAIL,"VSattach");
status=Vsetname(vg1, VGROUP1);
CHECK_VOID(status,FAIL,"VSsetname");
status=Vsetclass(vg1, VG_LONGCLASS);
CHECK_VOID(status,FAIL,"VSsetname");
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
status = Vend(file_id);
CHECK_VOID(status,FAIL,"Vend");
status = Hclose(file_id);
CHECK_VOID(status,FAIL,"Hclose");
/* Re-open the HDF file. */
file_id = Hopen(LONGNAMES, DFACC_RDWR, 0);
CHECK_VOID(file_id,FAIL,"Hopen");
/* Initialize HDF for subsequent vgroup/vdata access. */
status = Vstart(file_id);
CHECK_VOID(status,FAIL,"Vstart");
/* Find the long name vgroup. */
ref=Vfind(file_id,VG_LONGNAME);
CHECK_VOID(ref,FAIL,"VSfind");
vg1 = Vattach(file_id, ref, "r");
CHECK_VOID(vg1,FAIL,"VSattach");
/* Test Vgisinternal */
is_internal = Vgisinternal(vg1);
CHECK_VOID(is_internal, FAIL, "Vgisinternal");
VERIFY_VOID(is_internal, FALSE, "Vgisinternal");
/* get the vgroup's name */
status = Vgetnamelen(vg1, &name_len);
CHECK_VOID(status,FAIL,"Vgetnamelen");
vgname = (char *) HDmalloc(sizeof(char *) * (name_len+1));
CHECK_ALLOC(vgname, "vgname", "test_vglongnames" );
status=Vgetname(vg1, vgname);
CHECK_VOID(status,FAIL,"VSgetname");
VERIFY_CHAR_VOID(vgname, VG_LONGNAME, "Vgetname");
if (vgname != NULL)
HDfree(vgname);
/* get the vgroup's class */
status = Vgetclassnamelen(vg1, &name_len);
CHECK_VOID(status,FAIL,"Vgetnamelen");
vgclass = (char *) HDmalloc(sizeof(char *) * (name_len+1));
CHECK_ALLOC(vgclass, "vgclass", "test_vglongnames" );
status=Vgetclass(vg1, vgclass);
CHECK_VOID(status,FAIL,"VSgetclass");
VERIFY_CHAR_VOID(vgclass, VG_LONGCLASS, "Vgetclass");
if (vgclass != NULL)
HDfree(vgclass);
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
/* Find the vgroup VGROUP1. */
ref=Vfind(file_id,VGROUP1);
CHECK_VOID(ref,FAIL,"VSfind");
vg1 = Vattach(file_id, ref, "r");
CHECK_VOID(vg1,FAIL,"VSattach");
/* get the vgroup's name */
status = Vgetnamelen(vg1, &name_len);
CHECK_VOID(status,FAIL,"Vgetnamelen");
vgname = (char *) HDmalloc(sizeof(char *) * (name_len+1));
CHECK_ALLOC(vgname, "vgname", "test_vglongnames" );
status=Vgetname(vg1, vgname);
CHECK_VOID(status,FAIL,"VSgetname");
if (HDstrcmp(vgname, VGROUP1)) {
num_errs++;
printf(">>> Got bogus Vgroup name : %s\n", vgname);
}
if (vgname != NULL)
HDfree(vgname);
/* get the vgroup's class */
status = Vgetclassnamelen(vg1, &name_len);
CHECK_VOID(status,FAIL,"Vgetnamelen");
vgclass = (char *) HDmalloc(sizeof(char *) * (name_len+1));
CHECK_ALLOC(vgclass, "vgclass", "test_vglongnames" );
status=Vgetclass(vg1, vgclass);
CHECK_VOID(status,FAIL,"VSgetclass");
if (HDstrcmp(vgclass, VG_LONGCLASS)) {
num_errs++;
printf(">>> Got bogus Vgroup class : %s\n", vgclass);
}
if (vgclass != NULL)
HDfree(vgclass);
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
status = Vend(file_id);
CHECK_VOID(status,FAIL,"Vend");
status = Hclose(file_id);
CHECK_VOID(status,FAIL,"Hclose");
} /* test_vglongnames() */
static void
test_undefined(void)
{
int32 status; /* Status values from routines */
int32 file_id; /* File ID */
int32 vg1; /* Vdata ID */
int32 ref; /* Vdata ref */
intn is_internal; /* to test Vgisinternal */
uint16 name_len; /* Length of a vgroup's name or class name */
/* to simulate calls to Vgetclass/Vgetname in older applications */
char vgname[VGNAMELENMAX+1], vgclass[VGNAMELENMAX+1];
/* Open the HDF file. */
file_id = Hopen(NONAMECLASS, DFACC_CREATE, 0);
CHECK_VOID(file_id,FAIL,"Hopen");
/* Initialize HDF for subsequent vgroup/vdata access. */
status = Vstart(file_id);
CHECK_VOID(status,FAIL,"Vstart");
/* Create a vgroup which will have name set but not class */
vg1 = Vattach(file_id, -1, "w");
CHECK_VOID(vg1,FAIL,"VSattach");
status=Vsetname(vg1, VG_LONGNAME);
CHECK_VOID(status,FAIL,"VSsetname");
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
/* Create another vgroup which will have class but not name */
vg1 = Vattach(file_id, -1, "w");
CHECK_VOID(vg1,FAIL,"VSattach");
status=Vsetclass(vg1, VG_LONGCLASS);
CHECK_VOID(status,FAIL,"VSsetname");
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
status = Vend(file_id);
CHECK_VOID(status,FAIL,"Vend");
status = Hclose(file_id);
CHECK_VOID(status,FAIL,"Hclose");
/* Re-open the HDF file. */
file_id = Hopen(NONAMECLASS, DFACC_RDWR, 0);
CHECK_VOID(file_id,FAIL,"Hopen");
/* Initialize HDF for subsequent vgroup/vdata access. */
status = Vstart(file_id);
CHECK_VOID(status,FAIL,"Vstart");
/* Find the long name vgroup. */
ref=Vfind(file_id,VG_LONGNAME);
CHECK_VOID(ref,FAIL,"VSfind");
vg1 = Vattach(file_id, ref, "r");
CHECK_VOID(vg1,FAIL,"VSattach");
/* Test Vgisinternal */
is_internal = Vgisinternal(vg1);
CHECK_VOID(is_internal, FAIL, "Vgisinternal");
VERIFY_VOID(is_internal, FALSE, "Vgisinternal");
/* Try getting the vgroup's class without calling first Vgetclassnamelen.
This shows that bug HDFFR-1288 is fixed. */
status=Vgetclass(vg1, vgclass);
CHECK_VOID(status,FAIL,"Vgetclass");
VERIFY_VOID(HDstrlen(vgclass), 0, "VSgetclass");
/* The length of the class name should be 0 */
status = Vgetclassnamelen(vg1, &name_len);
CHECK_VOID(status,FAIL,"Vgetclassnamelen");
VERIFY_VOID(name_len, 0, "VSgetclassnamelen");
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
/* Find the vgroup with class VG_LONGCLASS. This vgroup doesn't have a name */
ref=Vfindclass(file_id, VG_LONGCLASS);
CHECK_VOID(ref,FAIL,"VSfindclass");
vg1 = Vattach(file_id, ref, "r");
CHECK_VOID(vg1,FAIL,"VSattach");
/* Try getting the vgroup's name without calling first Vgetclassnamelen.
Similar to class name in bug HDFFR-1288. */
status=Vgetname(vg1, vgname);
CHECK_VOID(status,FAIL,"Vgetname");
VERIFY_VOID(HDstrlen(vgname), 0, "VSgetname");
/* The length of the name should be 0 */
status = Vgetnamelen(vg1, &name_len);
CHECK_VOID(status,FAIL,"Vgetnamelen");
VERIFY_VOID(name_len, 0, "VSgetnamelen");
status = Vdetach(vg1);
CHECK_VOID(status,FAIL,"Vdetach");
status = Vend(file_id);
CHECK_VOID(status,FAIL,"Vend");
status = Hclose(file_id);
CHECK_VOID(status,FAIL,"Hclose");
} /* test_undefined() */
int main( )
{
/************************* Variable declaration **************************/
intn status_n; /* returned status for functions returning an intn */
int32 status_32, /* returned status for functions returning an int32 */
file_id, vdata_ref, vdata_id,
field_index, /* index of a field within the vdata */
n_vdattrs, /* number of vdata attributes */
n_fldattrs, /* number of field attributes */
vdata_type, /* to hold the type of vdata's attribute */
vdata_n_values,/* to hold the number of vdata's attribute values */
vdata_size, /* to hold the size of vdata's attribute values */
field_type, /* to hold the type of field's attribute */
field_n_values,/* to hold the number of field's attribute values */
field_size; /* to hold the size of field's attribute values */
char vd_attr[VATTR_N_VALUES] = {'A', 'B', 'C'};/* vdata attribute values*/
int32 fld_attr[FATTR_N_VALUES] = {2, 4, 6, 8}; /* field attribute values*/
char vattr_buf[VATTR_N_VALUES]; /* to hold vdata attribute's values */
int32 fattr_buf[FATTR_N_VALUES]; /* to hold field attribute's values */
char vattr_name[30], /* name of vdata attribute */
fattr_name[30]; /* name of field attribute */
/********************** End of variable declaration **********************/
/*
* Open the HDF file for writing.
*/
file_id = Hopen (FILE_NAME, DFACC_WRITE, 0);
/*
* Initialize the VS interface.
*/
status_n = Vstart (file_id);
/*
* Get the reference number of the vdata named VDATA_NAME.
*/
vdata_ref = VSfind (file_id, VDATA_NAME);
/*
* Attach to the vdata for writing.
*/
vdata_id = VSattach (file_id, vdata_ref, "w");
/*
* Attach an attribute to the vdata, i.e., indicated by the second parameter.
*/
status_n = VSsetattr (vdata_id, _HDF_VDATA, VATTR_NAME, DFNT_CHAR,
VATTR_N_VALUES, vd_attr);
/*
* Get the index of the field FIELD_NAME within the vdata.
*/
status_n = VSfindex (vdata_id, FIELD_NAME, &field_index);
/*
* Attach an attribute to the field field_index.
*/
status_n = VSsetattr (vdata_id, field_index, FATTR_NAME, DFNT_INT32,
FATTR_N_VALUES, fld_attr);
/*
* Get the number of attributes attached to the vdata's first
* field - should be 0.
*/
n_fldattrs = VSfnattrs (vdata_id, 0);
printf ( "Number of attributes of the first field of the vdata: %d\n",
n_fldattrs);
/*
* Get the number of attributes attached to the field specified by
* field_index - should be 1.
*/
n_fldattrs = VSfnattrs (vdata_id, field_index);
printf ( "Number of attributes of field %s: %d\n", FIELD_NAME, n_fldattrs);
/*
* Get the total number of the field's and vdata's attributes - should be 2.
*/
n_vdattrs = VSnattrs (vdata_id);
printf ( "Number of attributes of the vdata and its fields: %d\n",
n_vdattrs);
/*
* Get information about the vdata's first attribute, indicated
* by the third parameter which is the index of the attribute.
*/
status_n = VSattrinfo (vdata_id, _HDF_VDATA, 0, vattr_name,
&vdata_type, &vdata_n_values, &vdata_size);
/*
* Get information about the first attribute of the field specified by
* field_index.
*/
status_n = VSattrinfo (vdata_id, field_index, 0, fattr_name, &field_type,
&field_n_values, &field_size);
/*
* Get the vdata's first attribute.
*/
status_n = VSgetattr (vdata_id, _HDF_VDATA, 0, vattr_buf);
printf("Values of the vdata attribute = %c %c %c\n", vattr_buf[0],
vattr_buf[1], vattr_buf[2]);
/*
* Get the first attribute of the field specified by field_index.
*/
status_n = VSgetattr (vdata_id, field_index, 0, fattr_buf);
printf("Values of the field attribute = %d %d %d %d\n", fattr_buf[0],
fattr_buf[1], fattr_buf[2], fattr_buf[3]);
/*
* Terminate access to the vdata and to the VS interface, then close
* the HDF file.
*/
status_32 = VSdetach (vdata_id);
status_n = Vend (file_id);
status_32 = Hclose (file_id);
return 0;
}
int coda_hdf4_close(coda_product *product)
{
coda_hdf4_product *product_file = (coda_hdf4_product *)product;
int i;
if (product_file->filename != NULL)
{
free(product_file->filename);
}
if (product_file->mem_ptr != NULL)
{
free(product_file->mem_ptr);
}
/* first remove everything that was not added to the root_type */
if (product_file->vgroup != NULL)
{
for (i = 0; i < product_file->num_vgroup; i++)
{
if (product_file->vgroup[i] != NULL && (product_file->vgroup[i]->group_count != 0 ||
product_file->vgroup[i]->hide))
{
coda_dynamic_type_delete((coda_dynamic_type *)product_file->vgroup[i]);
}
}
free(product_file->vgroup);
}
if (product_file->vdata != NULL)
{
for (i = 0; i < product_file->num_vdata; i++)
{
if (product_file->vdata[i] != NULL && (product_file->vdata[i]->group_count != 0 ||
product_file->vdata[i]->hide))
{
coda_dynamic_type_delete((coda_dynamic_type *)product_file->vdata[i]);
}
}
free(product_file->vdata);
}
if (product_file->sds != NULL)
{
for (i = 0; i < product_file->num_sds; i++)
{
if (product_file->sds[i] != NULL && product_file->sds[i]->group_count != 0)
{
coda_dynamic_type_delete((coda_dynamic_type *)product_file->sds[i]);
}
}
free(product_file->sds);
}
if (product_file->gri != NULL)
{
for (i = 0; i < product_file->num_images; i++)
{
if (product_file->gri[i] != NULL && product_file->gri[i]->group_count != 0)
{
coda_dynamic_type_delete((coda_dynamic_type *)product_file->gri[i]);
}
}
free(product_file->gri);
}
/* then remove the root_type (which recursively removes its members) */
if (product_file->root_type != NULL)
{
coda_dynamic_type_delete((coda_dynamic_type *)product_file->root_type);
}
if (product_file->sd_id != -1)
{
SDend(product_file->sd_id);
}
if (product_file->is_hdf)
{
if (product_file->gr_id != -1)
{
GRend(product_file->gr_id);
}
if (product_file->an_id != -1)
{
ANend(product_file->an_id);
}
if (product_file->file_id != -1)
{
Vend(product_file->file_id);
Hclose(product_file->file_id);
}
}
free(product_file);
return 0;
}
//// [[Rcpp::export]]
int binlist(int x) {
int numbins = 0, *binnums = NULL;
int i;
int file_id,vdata_ref, vdata_id,numrecs,pvd_id;
char PARAM[] = "chlor_a";
initbin();
/* Open the HDF file. */
file_id = Hopen("S1998001.L3b_DAY_CHL.main", DFACC_READ, 0);
if(file_id == FAIL){
fprintf(stderr,"-E- %s line %d: Hopen(%s,DFACC_READ,0) failed.\n",
__FILE__,__LINE__,"S1998001.L3b_DAY_CHL.main");
return(EXIT_FAILURE);
}
/* Initialize the Vdata interface. */
if(Vstart(file_id) == FAIL){
fprintf(stderr,"-E- %s line %d: Vstart(%d) failed.\n",
__FILE__,__LINE__,file_id);
return(EXIT_FAILURE);
}
/* Open the "BinList" Vdata. */
vdata_ref = VSfind(file_id,"BinList");
if(vdata_ref == FAIL){
fprintf(stderr,"-E- %s line %d: VSfind(%d,\"BinList\") failed.\n",
__FILE__,__LINE__,file_id);
return(EXIT_FAILURE);
}
vdata_id = VSattach(file_id, vdata_ref, "r");
if(vdata_id == FAIL){
fprintf(stderr,"-E- %s line %d: VSattach(%d,%d,\"r\") failed.\n",
__FILE__,__LINE__,file_id,vdata_ref);
return(EXIT_FAILURE);
}
/* Find out how many bins are stored in this file. */
numrecs = VSelts(vdata_id);
if(numrecs == FAIL){
fprintf(stderr,"-E- %s line %d: VSelts(%d) failed.\n",
__FILE__,__LINE__,vdata_id);
return(EXIT_FAILURE);
}
// this doesn't seem to be necessary?
/* Set up to read the fields in the BinList Vdata records. */
// if(VSsetfields(vdata_id,BLIST_FIELDS) == FAIL){
// fprintf(stderr,"-E- %s line %d: VSsetfields(%d,%s) failed.\n",
// __FILE__,__LINE__,vdata_id,BLIST_FIELDS);
// return(EXIT_FAILURE);
// }
/* Open the parameter-specific Vdata. */
vdata_ref = VSfind(file_id,PARAM);
if(vdata_ref == 0){
fprintf(stderr,"-E- %s line %d: VSfind(%d,\"%s\") failed.\n",
__FILE__,__LINE__,file_id,PARAM);
return(EXIT_FAILURE);
}
pvd_id = VSattach(file_id, vdata_ref, "r");
if(pvd_id == FAIL){
fprintf(stderr,"-E- %s line %d: VSattach(%d,%d,\"r\") failed.\n",
__FILE__,__LINE__,file_id,vdata_ref);
return(EXIT_FAILURE);
}
/* Set up to read the fields in the parameter-specific Vdata records. */
{
int len;
len = 2*strlen(PARAM) + strlen("_sum,") + strlen("_sum_sq") + 1;
param_fields = (char *)malloc(len);
if(param_fields == NULL){
fprintf(stderr,"-E- %s line %d: Memory allocation failed.\n",
__FILE__,__LINE__);
return(EXIT_FAILURE);
}
strcpy(param_fields,PARAM);
strcat(param_fields,"_sum,");
strcat(param_fields,PARAM);
strcat(param_fields,"_sum_sq");
}
if(VSsetfields(pvd_id,param_fields) == FAIL){
fprintf(stderr,"-E- %s line %d: VSsetfields(%d,%s) failed.\n",
__FILE__,__LINE__,pvd_id,param_fields);
return(EXIT_FAILURE);
}
printf(param_fields);
printf("\n");
/* Output a header record to identify the fields written out below. */
printf("%80s%15.15s %15.15s\n"," ",PARAM,PARAM);
printf(" bin centerlat centerlon");
printf(" north south west east");
printf(" n N sum_obs sum_squared_obs weight");
printf(" time_trend_bits l2_flag_bits sel\n");
printf("------- --------- ----------");
printf(" --------- --------- ---------- ----------");
printf(" ---- --- --------------- --------------- ---------------");
printf(" ---------------- -------------------------------- ---\n");
// for(i = 0; i < numbins; i++){
for(i = 0; i < 10; i++){
int recno;
// recno = binsearch(binnums[i],vdata_id,numrecs);
recno = i;
if(recno >= 0){
double n,s,w,e,clat,clon;
/*
Read the sum and sum-of-squares for the
the specified parameter for this bin.
*/
if(VSseek(pvd_id,recno) == FAIL){
fprintf(stderr,"-E- %s line %d: VSseek(%d,%d) failed.\n",
__FILE__,__LINE__,pvd_id,recno);
return(EXIT_FAILURE);
}
if(VSread(pvd_id,paramrec,1,FULL_INTERLACE) != 1){
fprintf(stderr,"-E- %s line %d: ",__FILE__,__LINE__);
fprintf(stderr,"VSread(%d,paramrec,1,FULL_INTERLACE) failed.\n",
pvd_id);
return(EXIT_FAILURE);
}
/*
VSfpack() sets the global sum and sum_sq variables
via the paramptrs pointer array.
*/
if(
VSfpack(
pvd_id,_HDF_VSUNPACK,param_fields,paramrec,PREC_SIZE,1,NULL,paramptrs
)
== FAIL){
fprintf(stderr,"-E- %s line %d: ",__FILE__,__LINE__);
fprintf(stderr,"VSfpack(%d, ...) failed.\n", pvd_id);
return(EXIT_FAILURE);
}
/* Get the geographical coordinates associated with this bin. */
// bin2latlon(binnums[i],&clat,&clon);
// bin2bounds(binnums[i],&n,&s,&w,&e);
/* Output the results. */
// printf("%7d %9.5f %10.5f %9.5f %9.5f %10.5f %10.5f ",
// binnums[i],clat,clon,n,s,w,e);
// printf("%4d %3d ",nobs,nscenes);
// printf("% .8e % .8e % .8e ",sum,sum_sq,weights);
printf("% .8e % .8e % .8e ",sum,sum_sq,0.0);
// printf("%.16s %.32s ",bitstr16(time_rec),bitstr32(flags_set));
// printf("%3d",sel_cat);
printf("\n");
}
}
if(VSdetach(pvd_id) == FAIL){
fprintf(stderr,"-E- %s line %d: VSdetach(%d) failed.\n",
__FILE__,__LINE__,pvd_id);
return(EXIT_FAILURE);
}
if(VSdetach(vdata_id) == FAIL){
fprintf(stderr,"-E- %s line %d: VSdetach(%d) failed.\n",
__FILE__,__LINE__,vdata_id);
return(EXIT_FAILURE);
}
if(Vend(file_id) == FAIL){
fprintf(stderr,"-E- %s line %d: Vend(%d) failed.\n",
__FILE__,__LINE__,file_id);
return(EXIT_FAILURE);
}
if(Hclose(file_id) == FAIL){
fprintf(stderr,"-E- %s line %d: Hclose(%d) failed.\n",
__FILE__,__LINE__,file_id);
return(EXIT_FAILURE);
}
free(param_fields);
free(binnums);
return 2;
}
int main( )
{
/************************* Variable declaration **************************/
intn status_n; /* returned status for functions returning an intn */
int32 status_32, /* returned status for functions returning an int32 */
file_id, vgroup_id, vgroup_ref, vdata_id, vdata_ref,
num_of_records, num_of_vals_per_rec, record_pos,
obj_index, /* index of an object within a vgroup */
num_of_pairs, /* number of tag/ref number pairs, i.e., objects */
obj_tag, obj_ref, /* tag/ref number of an HDF object */
vgroup_pos = 0; /* position of a vgroup in the file */
float32 databuf[N_RECORDS][N_VALS_PER_REC];
int16 rec_num;
/********************** End of variable declaration ***********************/
char FIELDNAME_LIST[MAX_FIELDNAME_LIST_LENGTH];
memset(FIELDNAME_LIST, 0x00, MAX_FIELDNAME_LIST_LENGTH);
int i;
for (i = 0; i < N_VALS_PER_REC; i++) {
char buffer[256];
if (i == 0) {
sprintf(buffer, "%d", i);
} else {
sprintf(buffer, " %d", i);
}
strcat(FIELDNAME_LIST, buffer);
}
file_id = Hopen (FILE_NAME, DFACC_READ, 0);
status_n = Vstart (file_id);
vgroup_ref = -1;
vgroup_ref = Vgetid (file_id, vgroup_ref);
if (vgroup_ref == -1) exit(1);
vgroup_ref = Vgetid (file_id, vgroup_ref);
if (vgroup_ref == -1) exit(1);
vgroup_id = Vattach (file_id, vgroup_ref, "r");
num_of_pairs = Vntagrefs (vgroup_id);
if (num_of_pairs > 0)
{
printf ("\nVgroup #%d contains:\n", vgroup_pos);
for (obj_index = 0; obj_index < num_of_pairs; obj_index++)
{
status_n = Vgettagref (vgroup_id, obj_index, &obj_tag, &obj_ref);
printf ("tag = %d, ref = %d", obj_tag, obj_ref);
if (Visvg (vgroup_id, obj_ref))
printf (" <-- is a vgroup\n");
else if (Visvs (vgroup_id, obj_ref)) {
printf (" <-- is a vdata\n");
vdata_ref = VSfind (file_id, VDATA_NAME);
vdata_id = VSattach (file_id, vdata_ref, "r");
status_n = VSsetfields (vdata_id, FIELDNAME_LIST);
record_pos = VSseek (vdata_id, RECORD_INDEX);
num_of_records =
VSread (vdata_id, (uint8 *)databuf, N_RECORDS, FULL_INTERLACE);
for (rec_num = 0; rec_num < num_of_records; rec_num++)
{
for (num_of_vals_per_rec = 0; num_of_vals_per_rec < N_VALS_PER_REC; num_of_vals_per_rec++) {
printf ("%6.2f\n", databuf[rec_num][num_of_vals_per_rec]);
}
}
}
else {
printf (" <-- neither vdata nor vgroup\n");
}
} /* for */
} /* if */
else
printf ("Vgroup #%d contains no HDF objects\n", vgroup_pos);
/*
* Terminate access to the current vgroup.
*/
status_32 = Vdetach (vgroup_id);
/*
* Move to the next vgroup position.
*/
vgroup_pos++;
/*
* Terminate access to the V interface and close the file.
*/
status_n = Vend (file_id);
status_n = Hclose (file_id);
return 0;
}