00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include <stdio.h>
00026 #include <string.h>
00027 #include <math.h>
00028 #include <ctype.h>
00029 #include <stdlib.h>
00030 #if defined(_WIN32) && !defined(__NUTC__)
00031 #include <io.h>
00032 #else
00033 #include <unistd.h>
00034 #endif
00035
00036 #include "ADFH.h"
00037 #include "hdf5.h"
00038 #ifdef USE_CGIO
00039 #include "cgns_io.h"
00040 #endif
00041
00042 #if H5_VERS_MAJOR < 2 && H5_VERS_MINOR < 8
00043 # error you need at least HDF5 version 1.8
00044 #endif
00045
00046 #undef ADFH_DEBUG_ON
00047 #define ADFH_NO_ORDER
00048 #define ADFH_USE_STRINGS
00049 #define ADFH_FORTRAN_INDEXING
00050 #define ADFH_COMPRESS_DATA
00051
00052 #ifdef ADFH_COMPRESS_DATA
00053 extern int cgns_compress;
00054 #endif
00055
00056 #define TO_UPPER( c ) ((islower(c))?(toupper(c)):(c))
00057
00058
00059
00060
00061
00062
00063
00064
00065 #define D_PREFIX ' '
00066 #ifdef ADFH_FORTRAN_INDEXING
00067 #define D_VERSION " hdf5version"
00068 #define D_OLDVERS " version"
00069 #else
00070 #define D_VERSION " version"
00071 #endif
00072 #define D_FORMAT " format"
00073 #define D_DATA " data"
00074 #define D_FILE " file"
00075 #define D_PATH " path"
00076 #define D_LINK " link"
00077
00078
00079
00080 #define A_NAME "name"
00081 #define A_LABEL "label"
00082 #define A_TYPE "type"
00083 #define A_ORDER "order"
00084 #define A_MOUNT "mount"
00085 #define A_FILE "file"
00086 #define A_REFCNT "refcnt"
00087 #define A_FLAGS "flags"
00088
00089
00090 #define ADFH_CHECK_HID( hid ) \
00091 if (hid <0) {printf("#### BAD ID [%5d] ",__LINE__);fflush(stdout); }
00092
00093 #define ADFH_PREFIX "#### DBG "
00094 #ifdef ADFH_DEBUG_ON
00095 #define ADFH_DEBUG(aaa) \
00096 printf("#### DBG [%5d] ",__LINE__);fflush(stdout); \
00097 printf aaa ; printf("\n"); fflush(stdout);
00098 #define DROP( msg ) printf("XX " msg "\n");fflush(stdout);
00099 #else
00100 #define ADFH_DEBUG(a) ;
00101 #define DROP( msg ) ;
00102 #endif
00103
00104
00105
00106 #define ADFH_MT "MT"
00107 #define ADFH_LK "LK"
00108 #define ADFH_B1 "B1"
00109 #define ADFH_C1 "C1"
00110 #define ADFH_I4 "I4"
00111 #define ADFH_I8 "I8"
00112 #define ADFH_U4 "U4"
00113 #define ADFH_U8 "U8"
00114 #define ADFH_R4 "R4"
00115 #define ADFH_R8 "R8"
00116
00117 #define ADFH_X4 "X4"
00118 #define ADFH_X8 "X8"
00119
00120
00121
00122 #define ADFH_MODE_NEW 1
00123 #define ADFH_MODE_OLD 2
00124 #define ADFH_MODE_RDO 3
00125
00126
00127
00128 #define ADFH_MAXIMUM_FILES 128
00129
00130
00131
00132
00133 typedef struct _ADFH_MTA {
00134 int g_init;
00135 int g_error_state;
00136 int i_start;
00137 int i_len;
00138 int n_length;
00139 int n_names;
00140 #ifdef ADFH_NO_ORDER
00141 int i_count;
00142 #endif
00143
00144 hid_t g_propfile;
00145 hid_t g_proplink;
00146 hid_t g_propdataset;
00147
00148
00149 int g_flags;
00150 hid_t g_files[ADFH_MAXIMUM_FILES];
00151
00152 } ADFH_MTA;
00153
00154 static ADFH_MTA *mta_root=NULL;
00155
00156
00157 static struct _ErrorList {
00158 int errcode;
00159 char *errmsg;
00160 } ErrorList[] = {
00161 {NO_ERROR, "No Error"},
00162 {STRING_LENGTH_ZERO, "String length of zero or blank string detected"},
00163 {STRING_LENGTH_TOO_BIG, "String length longer than maximum allowable length"},
00164 {TOO_MANY_ADF_FILES_OPENED,"Too many files opened"},
00165 {ADF_FILE_STATUS_NOT_RECOGNIZED,"File status was not recognized"},
00166 {FILE_OPEN_ERROR, "File-open error"},
00167 {NULL_STRING_POINTER, "A string pointer is NULL"},
00168 {REQUESTED_NEW_FILE_EXISTS,"File Open Error: NEW - File already exists"},
00169 {ADF_FILE_FORMAT_NOT_RECOGNIZED,"File format was not recognized"},
00170 {REQUESTED_OLD_FILE_NOT_FOUND,"File Open Error: OLD - File does not exist"},
00171 {MEMORY_ALLOCATION_FAILED,"Memory allocation failed"},
00172 {DUPLICATE_CHILD_NAME, "Duplicate child name under a parent node"},
00173 {ZERO_DIMENSIONS, "Node has no dimensions"},
00174 {BAD_NUMBER_OF_DIMENSIONS,"Node's number-of-dimensions is not in legal range"},
00175 {CHILD_NOT_OF_GIVEN_PARENT,"Specified child is NOT a child of the specified parent"},
00176 {INVALID_DATA_TYPE, "Invalid Data-Type"},
00177 {NULL_POINTER, "A pointer is NULL"},
00178 {NO_DATA, "Node has no data associated with it"},
00179 {END_OUT_OF_DEFINED_RANGE,"Bad end value"},
00180 {BAD_STRIDE_VALUE, "Bad stride value"},
00181 {MINIMUM_GT_MAXIMUM, "Minimum value is greater than the maximum value"},
00182 {DATA_TYPE_NOT_SUPPORTED, "The data format is not support on a particular machine"},
00183 {FILE_CLOSE_ERROR, "File Close error"},
00184 {START_OUT_OF_DEFINED_RANGE,"Bad start value"},
00185 {ZERO_LENGTH_VALUE, "A value of zero is not allowable"},
00186 {BAD_DIMENSION_VALUE, "Bad dimension value"},
00187 {BAD_ERROR_STATE, "Error state must be either a 0 (zero) or a 1 (one)"},
00188 {UNEQUAL_MEMORY_AND_DISK_DIMS,"Unequal dimensional specifications for disk and memory"},
00189 {NODE_IS_NOT_A_LINK, "The node is not a link. It was expected to be a link"},
00190 {LINK_TARGET_NOT_THERE, "The linked-to node does not exist"},
00191 {LINKED_TO_FILE_NOT_THERE,"The file of a linked-node is not accessable"},
00192 {INVALID_NODE_NAME, "Node name contains invalid characters"},
00193 {FFLUSH_ERROR, "H5Fflush:flush error"},
00194 {NULL_NODEID_POINTER, "The node ID pointer is NULL"},
00195 {MAX_FILE_SIZE_EXCEEDED, "The maximum size for a file exceeded"},
00196
00197 {ADFH_ERR_GLINK, "H5Glink:soft link creation failed"},
00198 {ADFH_ERR_NO_ATT, "Node attribute doesn't exist"},
00199 {ADFH_ERR_AOPEN, "H5Aopen:open of node attribute failed"},
00200 {ADFH_ERR_IGET_NAME, "H5Iget_name:failed to get node path from ID"},
00201 {ADFH_ERR_GMOVE, "H5Gmove:moving a node group failed"},
00202 {ADFH_ERR_GUNLINK, "H5Gunlink:node group deletion failed"},
00203 {ADFH_ERR_GOPEN, "H5Gopen:open of a node group failed"},
00204 {ADFH_ERR_DGET_SPACE, "H5Dget_space:couldn't get node dataspace"},
00205 {ADFH_ERR_DOPEN, "H5Dopen:open of the node data failed"},
00206 {ADFH_ERR_DEXTEND, "H5Dextend:couldn't extend the node dataspace"},
00207 {ADFH_ERR_DCREATE, "H5Dcreate:node data creation failed"},
00208 {ADFH_ERR_SCREATE_SIMPLE, "H5Screate_simple:dataspace creation failed"},
00209 {ADFH_ERR_ACREATE, "H5Acreate:node attribute creation failed"},
00210 {ADFH_ERR_GCREATE, "H5Gcreate:node group creation failed"},
00211 {ADFH_ERR_DWRITE, "H5Dwrite:write to node data failed"},
00212 {ADFH_ERR_DREAD, "H5Dread:read of node data failed"},
00213 {ADFH_ERR_AWRITE, "H5Awrite:write to node attribute failed"},
00214 {ADFH_ERR_AREAD, "H5Aread:read of node attribute failed"},
00215 {ADFH_ERR_FMOUNT, "H5Fmount:file mount failed"},
00216 {ADFH_ERR_LINK_MOVE, "Can't move a linked-to node"},
00217 {ADFH_ERR_LINK_DATA, "Can't change the data for a linked-to node"},
00218 {ADFH_ERR_LINK_NODE, "Parent of node is a link"},
00219 {ADFH_ERR_LINK_DELETE, "Can't delete a linked-to node"},
00220 {ADFH_ERR_NOT_HDF5_FILE, "File does not exist or is not a HDF5 file"},
00221 {ADFH_ERR_FILE_DELETE, "unlink (delete) of file failed"},
00222 {ADFH_ERR_FILE_INDEX, "couldn't get file index from node ID"},
00223 {ADFH_ERR_TCOPY, "H5Tcopy:copy of existing datatype failed"},
00224 {ADFH_ERR_AGET_TYPE, "H5Aget_type:couldn't get attribute datatype"},
00225 {ADFH_ERR_TSET_SIZE, "H5Tset_size:couldn't set datatype size"},
00226 {ADFH_ERR_NOT_IMPLEMENTED,"routine not implemented"},
00227 {ADFH_ERR_NOTXLINK, "H5L: Link target is not an HDF5 external link"},
00228 {ADFH_ERR_LIBREG, "HDF5: No external link feature available"},
00229 {ADFH_ERR_OBJINFO_FAILED, "HDF5: Internal problem with objinfo"},
00230 {ADFH_ERR_XLINK_NOVAL, "HDF5: No value for external link"},
00231 {ADFH_ERR_XLINK_UNPACK, "HDF5: Cannot unpack external link"},
00232 {ADFH_ERR_ROOTNULL, "HDF5: Root descriptor is NULL"},
00233 {ADFH_ERR_NEED_TRANSPOSE, "dimensions need transposed - open in modify mode"},
00234
00235 {ADFH_ERR_SENTINEL, "<None>"}
00236 };
00237
00238 #define NUM_ERRORS (sizeof(ErrorList)/sizeof(struct _ErrorList))
00239 #define ROOT_OR_DIE(err) \
00240 if (mta_root == NULL){set_error(ADFH_ERR_ROOTNULL, err);return;}
00241
00242
00243
00244 #define CMP_OSTAT(r,n) ((r)->objno[0]==(n)->objno[0] && \
00245 (r)->objno[1]==(n)->objno[1] && \
00246 (r)->fileno[0]==(n)->fileno[0] && \
00247 (r)->fileno[1]==(n)->fileno[1])
00248
00249 static herr_t gfind_by_name(hid_t, const char *, void *);
00250 static herr_t gprint_name(hid_t, const char *, void *);
00251 static herr_t find_by_name(hid_t, const char *, const H5A_info_t*, void *);
00252 static herr_t print_name(hid_t, const char *, const H5A_info_t*, void *);
00253
00254 #define has_child(ID,NAME) H5Giterate(ID,".",NULL,gfind_by_name,(void *)NAME)
00255 #define has_data(ID) H5Giterate(ID,".",NULL,gfind_by_name,(void *)D_DATA)
00256 #define show_grp(ID) H5Giterate(ID,".",NULL,gprint_name,(void *)"GRP")
00257
00258 #define has_att(ID,NAME) H5Aiterate2(ID,H5_INDEX_NAME,H5_ITER_NATIVE,NULL,find_by_name,(void *)NAME)
00259 #define show_att(ID,NAME) H5Aiterate2(ID,H5_INDEX_NAME,H5_ITER_NATIVE,NULL,print_name,(void *)NAME)
00260
00261
00262
00263
00264
00265 static void set_error(int errcode, int *err)
00266 {
00267 if ((mta_root != NULL)&&(errcode != NO_ERROR)&&(mta_root->g_error_state))
00268 {
00269 char errmsg[ADF_MAX_ERROR_STR_LENGTH+1];
00270 ADFH_Error_Message(errcode, errmsg);
00271 fprintf(stderr, "ERROR:%s\n", errmsg);
00272 exit(1);
00273 }
00274 *err = errcode;
00275 }
00276
00277
00278
00279 static herr_t print_H5_error(int n, H5E_error2_t *desc, void *data)
00280 {
00281 const char *p;
00282
00283 if ((p = strrchr(desc->file_name, '/')) == NULL &&
00284 (p = strrchr(desc->file_name, '\\')) == NULL)
00285 p = desc->file_name;
00286 else
00287 p++;
00288 fprintf(stderr, "%s line %u in %s(): %s\n", p,
00289 desc->line, desc->func_name, desc->desc);
00290 return 0;
00291 }
00292
00293
00294
00295 static herr_t walk_H5_error(hid_t estack, void *data)
00296 {
00297 if ((mta_root != NULL) && (mta_root->g_error_state)) {
00298 fflush(stdout);
00299 fprintf(stderr, "\nHDF5 Error Trace Back\n");
00300 return H5Ewalk2(H5E_DEFAULT, H5E_WALK_DOWNWARD,
00301 (H5E_walk2_t)print_H5_error, data);
00302 }
00303 return 0;
00304 }
00305
00306
00307
00308
00309
00310 static char *native_format(void)
00311 {
00312 static char format[ADF_FORMAT_LENGTH+1];
00313 hid_t type = H5Tcopy(H5T_NATIVE_FLOAT);
00314
00315 ADFH_CHECK_HID(type);
00316 if (H5Tequal(type, H5T_IEEE_F32BE))
00317 strcpy(format, "IEEE_BIG_32");
00318 else if (H5Tequal(type, H5T_IEEE_F32LE))
00319 strcpy(format, "IEEE_LITTLE_32");
00320 else if (H5Tequal(type, H5T_IEEE_F64BE))
00321 strcpy(format, "IEEE_BIG_64");
00322 else if (H5Tequal(type, H5T_IEEE_F64LE))
00323 strcpy(format, "IEEE_LITTLE_64");
00324 else
00325 sprintf(format, "NATIVE_%d", H5Tget_precision(type));
00326 H5Tclose(type);
00327 return format;
00328 }
00329
00330
00331
00332
00333
00334 #if 1
00335
00336 # define to_HDF_ID(ID) (hid_t) (ID)
00337 # define to_ADF_ID(ID) (double)(ID)
00338
00339 #else
00340 static union {
00341 hid_t hdf_id;
00342 double adf_id;
00343 } ID_CONVERT;
00344
00345 static hid_t to_HDF_ID (double adf_id) {
00346 ID_CONVERT.hdf_id = 0;
00347 ID_CONVERT.adf_id = adf_id;
00348 return ID_CONVERT.hdf_id;
00349 }
00350
00351 static double to_ADF_ID (hid_t hdf_id) {
00352 ID_CONVERT.adf_id = 0;
00353 ID_CONVERT.hdf_id = hdf_id;
00354 return ID_CONVERT.adf_id;
00355 }
00356 #endif
00357
00358
00359
00360
00361
00362 static hid_t get_att_id(hid_t id, const char *name, int *err)
00363 {
00364 hid_t aid = H5Aopen_name(id, name);
00365
00366
00367 if (aid < 0) {
00368 if (!has_att(id, name))
00369 set_error(ADFH_ERR_NO_ATT, err);
00370 else
00371 set_error(ADFH_ERR_AOPEN, err);
00372 }
00373 else
00374 set_error(NO_ERROR, err);
00375 return aid;
00376 }
00377
00378
00379 static int new_str_att(hid_t id, const char *name, const char *value,
00380 int max_size, int *err)
00381 {
00382 #ifdef ADFH_USE_STRINGS
00383 hid_t sid, tid, aid;
00384 herr_t status;
00385
00386
00387
00388
00389
00390
00391
00392 sid = H5Screate(H5S_SCALAR);
00393 if (sid < 0) {
00394 set_error(ADFH_ERR_SCREATE_SIMPLE, err);
00395 return 1;
00396 }
00397
00398 tid = H5Tcopy(H5T_C_S1);
00399 if (tid < 0) {
00400 H5Sclose(sid);
00401 set_error(ADFH_ERR_TCOPY, err);
00402 return 1;
00403 }
00404 if (H5Tset_size(tid, max_size + 1) < 0) {
00405 H5Tclose(tid);
00406 H5Sclose(sid);
00407 set_error(ADFH_ERR_TSET_SIZE, err);
00408 return 1;
00409 }
00410
00411 aid = H5Acreate(id, name, tid, sid, H5P_DEFAULT, H5P_DEFAULT);
00412 if (aid < 0) {
00413 H5Tclose(tid);
00414 H5Sclose(sid);
00415 set_error(ADFH_ERR_ACREATE, err);
00416 return 1;
00417 }
00418
00419 status = H5Awrite(aid, tid, value);
00420
00421 H5Aclose(aid);
00422 H5Tclose(tid);
00423 H5Sclose(sid);
00424
00425 if (status < 0) {
00426 set_error(ADFH_ERR_AWRITE, err);
00427 return 1;
00428 }
00429 set_error(NO_ERROR, err);
00430 return 0;
00431 #else
00432
00433 hid_t sid, aid;
00434 hsize_t dim;
00435 herr_t status;
00436 char buff[ADF_FILENAME_LENGTH+1];
00437
00438 dim = max_size + 1;
00439 sid = H5Screate_simple(1, &dim, NULL);
00440 if (sid < 0) {
00441 set_error(ADFH_ERR_SCREATE_SIMPLE, err);
00442 return 1;
00443 }
00444
00445 aid = H5Acreate(id, name, H5T_NATIVE_CHAR, sid, H5P_DEFAULT, H5P_DEFAULT);
00446 if (aid < 0) {
00447 H5Sclose(sid);
00448 set_error(ADFH_ERR_ACREATE, err);
00449 return 1;
00450 }
00451
00452 memset(buff, 0, ADF_FILENAME_LENGTH+1);
00453 strcpy(buff, value);
00454 status = H5Awrite(aid, H5T_NATIVE_CHAR, buff);
00455
00456 H5Aclose(aid);
00457 H5Sclose(sid);
00458
00459 if (status < 0) {
00460 set_error(ADFH_ERR_AWRITE, err);
00461 return 1;
00462 }
00463 set_error(NO_ERROR, err);
00464 return 0;
00465 #endif
00466 }
00467
00468
00469 static int get_str_att(hid_t id, const char *name, char *value, int *err)
00470 {
00471 #ifdef ADFH_USE_STRINGS
00472 hid_t tid, att_id;
00473 herr_t status;
00474
00475 ADFH_DEBUG((">ADFH get_str_att [%s]",name));
00476 if ((att_id = get_att_id(id, name, err)) < 0) return 1;
00477 #if 0
00478 status = H5Aread(att_id, H5T_NATIVE_CHAR, value);
00479 #else
00480 tid = H5Aget_type(att_id);
00481 if (tid < 0) {
00482 H5Aclose(att_id);
00483 set_error(ADFH_ERR_AGET_TYPE, err);
00484 return 1;
00485 }
00486 status = H5Aread(att_id, tid, value);
00487 H5Tclose(tid);
00488 #endif
00489 H5Aclose(att_id);
00490 ADFH_DEBUG(("<ADFH get_str_att [%s][%s]",name,value));
00491 if (status < 0) {
00492 set_error(ADFH_ERR_AREAD, err);
00493 return 1;
00494 }
00495 return 0;
00496 #else
00497
00498 hid_t att_id;
00499 herr_t status;
00500 char buff[ADF_FILENAME_LENGTH+1];
00501
00502 if ((att_id = get_att_id(id, name, err)) < 0) return 1;
00503 status = H5Aread(att_id, H5T_NATIVE_CHAR, buff);
00504 H5Aclose(att_id);
00505 strcpy(value, buff);
00506 if (status < 0) {
00507 set_error(ADFH_ERR_AREAD, err);
00508 return 1;
00509 }
00510 return 0;
00511 #endif
00512 }
00513
00514
00515
00516 static int set_str_att(hid_t id, const char *name, const char *value, int *err)
00517 {
00518 #ifdef ADFH_USE_STRINGS
00519 hid_t tid, att_id;
00520 herr_t status;
00521
00522 if ((att_id = get_att_id(id, name, err)) < 0) return 1;
00523 tid = H5Aget_type(att_id);
00524 if (tid < 0) {
00525 H5Aclose(att_id);
00526 set_error(ADFH_ERR_AGET_TYPE, err);
00527 return 1;
00528 }
00529 status = H5Awrite(att_id, tid, value);
00530 H5Tclose(tid);
00531 H5Aclose(att_id);
00532 if (status < 0) {
00533 set_error(ADFH_ERR_AWRITE, err);
00534 return 1;
00535 }
00536 return 0;
00537 #else
00538
00539 hid_t att_id;
00540 herr_t status;
00541 char buff[ADF_FILENAME_LENGTH+1];
00542
00543 if ((att_id = get_att_id(id, name, err)) < 0) return 1;
00544 memset(buff, 0, ADF_FILENAME_LENGTH+1);
00545 strcpy(buff, value);
00546 status = H5Awrite(att_id, H5T_NATIVE_CHAR, buff);
00547 H5Aclose(att_id);
00548 if (status < 0) {
00549 set_error(ADFH_ERR_AWRITE, err);
00550 return 1;
00551 }
00552 return 0;
00553 #endif
00554 }
00555
00556
00557
00558 static int new_int_att(hid_t id, const char *name, int value, int *err)
00559 {
00560 hid_t sid, aid;
00561 hsize_t dim;
00562 herr_t status;
00563 int buff = value;
00564
00565 dim = 1;
00566 sid = H5Screate_simple(1, &dim, NULL);
00567 if (sid < 0) {
00568 set_error(ADFH_ERR_SCREATE_SIMPLE, err);
00569 return 1;
00570 }
00571
00572 aid = H5Acreate(id, name, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT);
00573 if (aid < 0) {
00574 H5Sclose(sid);
00575 set_error(ADFH_ERR_ACREATE, err);
00576 return 1;
00577 }
00578
00579 status = H5Awrite(aid, H5T_NATIVE_INT, &buff);
00580
00581 H5Aclose(aid);
00582 H5Sclose(sid);
00583
00584 if (status < 0) {
00585 set_error(ADFH_ERR_AWRITE, err);
00586 return 1;
00587 }
00588 set_error(NO_ERROR, err);
00589 return 0;
00590 }
00591
00592
00593
00594 static int get_int_att(hid_t id, char *name, int *value, int *err)
00595 {
00596 hid_t att_id;
00597 herr_t status;
00598
00599 if ((att_id = get_att_id(id, name, err)) < 0) return 1;
00600 status = H5Aread(att_id, H5T_NATIVE_INT, value);
00601 H5Aclose(att_id);
00602 if (status < 0) {
00603 set_error(ADFH_ERR_AREAD, err);
00604 return 1;
00605 }
00606 return 0;
00607 }
00608
00609
00610
00611 static int set_int_att(hid_t id, char *name, int value, int *err)
00612 {
00613 hid_t att_id;
00614 herr_t status;
00615 int buff = value;
00616
00617 if ((att_id = get_att_id(id, name, err)) < 0) return 1;
00618 status = H5Awrite(att_id, H5T_NATIVE_INT, &buff);
00619 H5Aclose(att_id);
00620 if (status < 0) {
00621 set_error(ADFH_ERR_AWRITE, err);
00622 return 1;
00623 }
00624 return 0;
00625 }
00626
00627
00628
00629 static int new_str_data(hid_t id, const char *name, const char *value,
00630 int size, int *err)
00631 {
00632 hid_t sid, did;
00633 hsize_t dim;
00634 herr_t status;
00635
00636 dim = size+1;
00637 sid = H5Screate_simple(1, &dim, NULL);
00638 if (sid < 0) {
00639 set_error(ADFH_ERR_SCREATE_SIMPLE, err);
00640 return 1;
00641 }
00642
00643 did = H5Dcreate2(id, name, H5T_NATIVE_CHAR, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
00644 if (did < 0) {
00645 H5Sclose(sid);
00646 set_error(ADFH_ERR_DCREATE, err);
00647 return 1;
00648 }
00649
00650 status = H5Dwrite(did, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, H5P_DEFAULT, value);
00651 H5Dclose(did);
00652 H5Sclose(sid);
00653
00654 if (status < 0) {
00655 set_error(ADFH_ERR_DWRITE, err);
00656 return 1;
00657 }
00658 set_error(NO_ERROR, err);
00659 return 0;
00660 }
00661
00662
00663
00664
00665 static hid_t to_HDF_data_type(const char *tp)
00666 {
00667
00668 if (0 == strcmp(tp, ADFH_B1))
00669 return H5Tcopy(H5T_NATIVE_UCHAR);
00670 if (0 == strcmp(tp, ADFH_C1))
00671 return H5Tcopy(H5T_NATIVE_CHAR);
00672 if (0 == strcmp(tp, ADFH_I4))
00673 return H5Tcopy(H5T_NATIVE_INT32);
00674 if (0 == strcmp(tp, ADFH_I8))
00675 return H5Tcopy(H5T_NATIVE_INT64);
00676 if (0 == strcmp(tp, ADFH_U4))
00677 return H5Tcopy(H5T_NATIVE_UINT32);
00678 if (0 == strcmp(tp, ADFH_U8))
00679 return H5Tcopy(H5T_NATIVE_UINT64);
00680 if (0 == strcmp(tp, ADFH_R4)) {
00681 hid_t tid = H5Tcopy(H5T_NATIVE_FLOAT);
00682 H5Tset_precision(tid, 32);
00683 return tid;
00684 }
00685 if (0 == strcmp(tp, ADFH_R8)) {
00686 hid_t tid = H5Tcopy(H5T_NATIVE_DOUBLE);
00687 H5Tset_precision(tid, 64);
00688 return tid;
00689 }
00690 return 0;
00691 }
00692
00693
00694
00695 static int check_data_type(const char *tp, int *err)
00696 {
00697 if (strcmp(tp, ADFH_B1) &&
00698 strcmp(tp, ADFH_C1) &&
00699 strcmp(tp, ADFH_I4) &&
00700 strcmp(tp, ADFH_I8) &&
00701 strcmp(tp, ADFH_U4) &&
00702 strcmp(tp, ADFH_U8) &&
00703 strcmp(tp, ADFH_R4) &&
00704 strcmp(tp, ADFH_R8)) {
00705 set_error(INVALID_DATA_TYPE, err);
00706 return 1;
00707 }
00708 set_error(NO_ERROR, err);
00709 return 0;
00710 }
00711
00712
00713
00714
00715
00716
00717
00718 static herr_t gfind_by_name(hid_t id, const char *name, void *dsname)
00719 {
00720 if (0 == strcmp (name, (char *)dsname)) return 1;
00721 return 0;
00722 }
00723
00724
00725
00726 static herr_t gprint_name(hid_t id, const char *name, void *dsname)
00727 {
00728 return 0;
00729 }
00730
00731
00732
00733 static herr_t find_by_name(hid_t id, const char *name, const H5A_info_t* ainfo, void *dsname)
00734 {
00735 ADFH_CHECK_HID(id);
00736 if (0 == strcmp (name, (char *)dsname)) return 1;
00737 return 0;
00738 }
00739
00740
00741
00742 static herr_t print_name(hid_t id, const char *name, const H5A_info_t* ainfo, void *dsname)
00743 {
00744 printf("[%s]:[%s]\n",dsname,name);
00745 return 0;
00746 }
00747
00748
00749
00750 static herr_t count_children(hid_t id, const char *name, void *number)
00751 {
00752 ADFH_CHECK_HID(id);
00753 ADFH_DEBUG(("count_children [%s][%d]",name,(*((int *)number))));
00754
00755 if (*name != D_PREFIX)
00756 (*((int *)number))++;
00757 return 0;
00758 }
00759
00760
00761
00762 static herr_t children_names(hid_t id, const char *name, void *namelist)
00763 {
00764 hid_t gid;
00765 int order, err;
00766 char *p;
00767
00768 ROOT_OR_DIE(&err);
00769 if (*name == D_PREFIX) return 0;
00770 #ifdef ADFH_NO_ORDER
00771 order = ++mta_root->i_count - mta_root->i_start;
00772 if (order >= 0 && order < mta_root->i_len) {
00773 p = (char *)namelist + order * mta_root->n_length;
00774 strncpy(p, name, mta_root->n_length-1);
00775 p[mta_root->n_length-1] = 0;
00776 mta_root->n_names++;
00777 }
00778 #else
00779 if ((gid = H5Gopen2(id, name, H5P_DEFAULT)) < 0) return 1;
00780 if (get_int_att(gid, A_ORDER, &order, &err)) {
00781 H5Gclose(gid);
00782 return 1;
00783 }
00784 order -= mta_root->i_start;
00785 if (order >= 0 && order < mta_root->i_len) {
00786 p = (char *)namelist + order * mta_root->n_length;
00787 strncpy(p, name, mta_root->n_length-1);
00788 p[mta_root->n_length-1] = 0;
00789 mta_root->n_names++;
00790 }
00791 H5Gclose(gid);
00792 #endif
00793 return 0;
00794 }
00795
00796
00797
00798 static herr_t children_ids(hid_t id, const char *name, void *idlist)
00799 {
00800 hid_t gid;
00801 int order, err;
00802
00803 ADFH_DEBUG((">ADFH children_ids [%s]",name));
00804 ROOT_OR_DIE(&err);
00805 if (*name == D_PREFIX) return 0;
00806 if ((gid = H5Gopen2(id, name, H5P_DEFAULT)) < 0) return 1;
00807 #ifdef ADFH_NO_ORDER
00808 order = ++mta_root->i_count - mta_root->i_start;
00809 if (order >= 0 && order < mta_root->i_len) {
00810 ((double *)idlist)[order] = to_ADF_ID(gid);
00811 mta_root->n_names++;
00812 }
00813 else
00814 H5Gclose(gid);
00815 #else
00816 if (get_int_att(gid, A_ORDER, &order, &err)) {
00817 H5Gclose(gid);
00818 return 1;
00819 }
00820 order -= mta_root->i_start;
00821 if (order >= 0 && order < mta_root->i_len) {
00822 ((double *)idlist)[order] = to_ADF_ID(gid);
00823 mta_root->n_names++;
00824 }
00825 else
00826 H5Gclose(gid);
00827 #endif
00828 return 0;
00829 }
00830
00831
00832
00833
00834
00835 static herr_t fix_order(hid_t id, const char *name, void *data)
00836 {
00837 int start, order, err, ret = 0;
00838 hid_t gid, aid;
00839
00840 if (mta_root == NULL) return ADFH_ERR_ROOTNULL;
00841 if (*name == D_PREFIX) return 0;
00842 if ((gid = H5Gopen2(id, name, H5P_DEFAULT)) < 0)
00843 return ADFH_ERR_GOPEN;
00844 if ((aid = get_att_id(gid, A_ORDER, &err)) < 0) {
00845 H5Gclose(gid);
00846 return err;
00847 }
00848 if (H5Aread(aid, H5T_NATIVE_INT, &order) < 0)
00849 ret = ADFH_ERR_AREAD;
00850 else {
00851 start = *((int *)data);
00852 if (order > start) {
00853 order--;
00854 if (H5Awrite(aid, H5T_NATIVE_INT, &order) < 0)
00855 ret = ADFH_ERR_AWRITE;
00856 }
00857 }
00858 H5Aclose(aid);
00859 H5Gclose(gid);
00860 return ret;
00861 }
00862
00863
00864
00865 static herr_t compare_children(hid_t id, const char *name, void *data)
00866 {
00867 H5G_stat_t stat, *pstat;
00868
00869 if (*name != D_PREFIX) {
00870 pstat = (H5G_stat_t *)data;
00871 if (H5Gget_objinfo(id, name, 0, &stat) >= 0)
00872 return CMP_OSTAT(&stat, pstat);
00873 }
00874 return 0;
00875 }
00876
00877
00878
00879 static herr_t print_children(hid_t id, const char *name, void *data)
00880 {
00881 if (*name != D_PREFIX)
00882 printf(" %s", name);
00883 return 0;
00884 }
00885
00886
00887
00888
00889
00890 static hid_t get_file_id (hid_t id)
00891 {
00892 int n, nobj;
00893 hid_t *objs, fid = -1;
00894 H5G_stat_t gstat, rstat;
00895
00896
00897
00898 if (H5Gget_objinfo(id, "/", 0, &gstat) >= 0) {
00899 nobj = H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_FILE);
00900 if (nobj > 0) {
00901 objs = (hid_t *) malloc (nobj * sizeof(hid_t));
00902 if (objs == NULL) return fid;
00903 H5Fget_obj_ids(H5F_OBJ_ALL, H5F_OBJ_FILE, -1, objs);
00904 for (n = 0; n < nobj; n++) {
00905 H5Gget_objinfo(objs[n], "/", 0, &rstat);
00906 if (CMP_OSTAT(&gstat, &rstat)) {
00907 fid = objs[n];
00908 break;
00909 }
00910 }
00911 free (objs);
00912 }
00913 }
00914 return fid;
00915 }
00916
00917
00918
00919 static int get_file_number (hid_t id, int *err)
00920 {
00921 int n;
00922 hid_t fid = get_file_id(id);
00923
00924 if (mta_root == NULL) return -1;
00925 for (n = 0; n < ADFH_MAXIMUM_FILES; n++) {
00926 if (fid == mta_root->g_files[n]) {
00927 set_error(NO_ERROR, err);
00928 return n;
00929 }
00930 }
00931 set_error(ADFH_ERR_FILE_INDEX, err);
00932 return -1;
00933 }
00934
00935
00936
00937
00938 static hid_t open_link(hid_t id, int *err)
00939 {
00940 hid_t lid;
00941 herr_t herr;
00942
00943 const char *file;
00944 const char *path;
00945 H5G_stat_t sb;
00946
00947 char *objectbuff,querybuff[512];
00948
00949 #ifdef ADFH_DEBUG_ON
00950 char buffname[ADF_NAME_LENGTH+1];
00951 get_str_att(id, A_NAME, buffname, err);
00952
00953 ADFH_DEBUG((">ADFH open_link [%s]",buffname));
00954 #endif
00955
00956 if (H5Lis_registered(H5L_TYPE_EXTERNAL) != 1)
00957 {
00958 set_error(ADFH_ERR_LIBREG, err);
00959 return;
00960 }
00961 herr=H5Gget_objinfo(id, D_LINK, (hbool_t)0, &sb);
00962
00963 if (herr<0)
00964 {
00965 ADFH_DEBUG((">ADFH open_link type [%d][%d]",herr,sb.type));
00966 set_error(ADFH_ERR_OBJINFO_FAILED, err);
00967 return;
00968 }
00969
00970
00971
00972
00973 if (H5G_LINK != sb.type)
00974 {
00975 if (H5G_UDLINK != sb.type)
00976 {
00977 set_error(ADFH_ERR_NOTXLINK, err);
00978 return;
00979 }
00980
00981 if (H5Lget_val(id,D_LINK,querybuff,sizeof(querybuff),H5P_DEFAULT)<0)
00982 {
00983 set_error(ADFH_ERR_XLINK_NOVAL, err);
00984 return;
00985 }
00986
00987 if (H5Lunpack_elink_val(querybuff,sb.linklen,NULL,&file,&path)<0)
00988 {
00989 set_error(ADFH_ERR_XLINK_UNPACK, err);
00990 return;
00991 }
00992
00993 ADFH_DEBUG((">ADFH open_link (external)"));
00994 if ((lid = H5Gopen2(id, D_LINK, H5P_DEFAULT)) < 0)
00995 {
00996 set_error(LINK_TARGET_NOT_THERE, err);
00997 return;
00998 }
00999 }
01000 else
01001 {
01002 ADFH_DEBUG((">ADFH open_link (symbolic)"));
01003 if ((lid = H5Gopen2(id, D_LINK, H5P_DEFAULT)) < 0)
01004 {
01005 set_error(LINK_TARGET_NOT_THERE, err);
01006 return;
01007 }
01008 }
01009
01010 ADFH_DEBUG(("<ADFH open_link "));
01011
01012 return lid;
01013 }
01014
01015
01016
01017 static int is_link(hid_t id)
01018 {
01019 char type[3];
01020 int err;
01021
01022 if ((!get_str_att(id, A_TYPE, type, &err) && (0 == strcmp(ADFH_LK, type))))
01023 {
01024 return 1;
01025 }
01026 return 0;
01027 }
01028
01029
01030
01031 static hid_t open_node(double id, int *err)
01032 {
01033 hid_t hid, gid, lid;
01034 H5G_stat_t sb;
01035
01036 ADFH_DEBUG((">ADFH open_node"));
01037 hid = to_HDF_ID(id);
01038 set_error(NO_ERROR, err);
01039 if (is_link(hid))
01040 {
01041 lid=open_link(hid, err);
01042 ADFH_DEBUG(("<ADFH open_node link"));
01043 return lid;
01044 }
01045 else
01046 {
01047 if ((gid = H5Gopen2(hid, ".", H5P_DEFAULT)) < 0)
01048 {
01049 set_error(ADFH_ERR_GOPEN, err);
01050 }
01051 else
01052 {
01053 ADFH_DEBUG(("<ADFH open_node group"));
01054
01055 return gid;
01056 }
01057 }
01058 }
01059
01060
01061
01062 static hid_t parse_path(hid_t pid, char *path, int *err)
01063 {
01064 hid_t id, nid;
01065 char *p;
01066
01067 if ((p = strchr(path, '/')) != NULL) *p++ = 0;
01068 if ((id = H5Gopen2(pid, path, H5P_DEFAULT)) < 0) {
01069 set_error(ADFH_ERR_GOPEN, err);
01070 return id;
01071 }
01072 if (p == NULL || !*p) return id;
01073 if (is_link(id)) {
01074 nid = open_link(id, err);
01075 if (H5Gclose(id)<0) ADFH_DEBUG((">ADFH H5Gclose failed"));
01076 if (nid < 0) return nid;
01077 id = nid;
01078 }
01079 nid = parse_path(id, p, err);
01080 if (H5Gclose(id)<0) ADFH_DEBUG((">ADFH H5Gclose failed"));
01081 return nid;
01082 }
01083
01084
01085
01086
01087
01088 static void delete_node(hid_t pid, const char *name)
01089 {
01090 H5Gunlink(pid, name);
01091 }
01092
01093
01094
01095 static herr_t delete_children(hid_t id, const char *name, void *data)
01096 {
01097 if (*name == D_PREFIX)
01098 {
01099 ADFH_DEBUG(("delete_children single"));
01100 if (! is_link(id))
01101 {
01102 ADFH_DEBUG(("delete_children is not link [%s]\n",name));
01103 H5Gunlink(id, name);
01104 }
01105 else
01106 {
01107 ADFH_DEBUG(("delete_children is link"));
01108 }
01109 ADFH_DEBUG(("delete_children single done"));
01110 }
01111 else {
01112 ADFH_DEBUG(("delete_children loop"));
01113 if (! is_link(id)) H5Giterate(id, name, NULL, delete_children, data);
01114 delete_node(id, name);
01115 }
01116 return 0;
01117 }
01118
01119
01120
01121
01122
01123
01124 static char *check_name(const char *new_name, int *err)
01125 {
01126 char *p;
01127 static char name[ADF_NAME_LENGTH+1];
01128
01129 if (new_name == NULL) {
01130 set_error(NULL_STRING_POINTER, err);
01131 return NULL;
01132 }
01133
01134
01135
01136 for (p = (char *)new_name; *p && isspace(*p); p++)
01137 ;
01138 if (!*p) {
01139 set_error(STRING_LENGTH_ZERO, err);
01140 return NULL;
01141 }
01142
01143 if (strlen(p) > ADF_NAME_LENGTH) {
01144 set_error(STRING_LENGTH_TOO_BIG, err);
01145 return NULL;
01146 }
01147 strcpy(name, p);
01148
01149
01150
01151 for (p = name+strlen(name)-1; p >= name && isspace(*p); p--)
01152 ;
01153 *++p = 0;
01154 if (!*name) {
01155 set_error(STRING_LENGTH_ZERO, err);
01156 return NULL;
01157 }
01158
01159
01160
01161 if (NULL != strchr(name, '/') || 0 == strcmp (name, ".")) {
01162 set_error(INVALID_NODE_NAME, err);
01163 return NULL;
01164 }
01165
01166 set_error(NO_ERROR, err);
01167 return name;
01168 }
01169
01170 #ifdef ADFH_FORTRAN_INDEXING
01171
01172
01173
01174
01175
01176 static int swap_dimensions (hid_t gid)
01177 {
01178 hid_t did;
01179 char verstr[ADF_NAME_LENGTH+1];
01180
01181 sprintf(verstr, "/%s", D_OLDVERS);
01182 if ((did = H5Dopen2(gid, verstr, H5P_DEFAULT)) < 0) return 1;
01183 H5Dclose(did);
01184 return 0;
01185 }
01186
01187 static void transpose_dimensions (hid_t hid, const char *name)
01188 {
01189 #if 0
01190 hid_t did, sid, tid, mid;
01191 int i, j, temp, ndims, diffs;
01192 hsize_t bytes, dims[ADF_MAX_DIMENSIONS];
01193 void *data = NULL;
01194 #else
01195 hid_t did, sid;
01196 int i, j, temp, ndims, diffs;
01197 hsize_t dims[ADF_MAX_DIMENSIONS];
01198 #endif
01199
01200 if ((did = H5Dopen2(hid, D_DATA, H5P_DEFAULT)) < 0) return;
01201
01202
01203 sid = H5Dget_space(did);
01204 ndims = H5Sget_simple_extent_dims(sid, dims, NULL);
01205 H5Sclose(sid);
01206 if (ndims < 2) {
01207 H5Dclose(did);
01208 return;
01209 }
01210 #if 0
01211 printf("%s:%d [%d", name, bytes, dims[0]);
01212 for (i = 1; i < ndims; i++) printf(",%d", dims[i]);
01213 printf("]\n");
01214 fflush(stdout);
01215 #endif
01216
01217
01218 diffs = 0;
01219 for (i = 0, j = ndims-1; i < j; i++, j--) {
01220 if (dims[i] != dims[j]) {
01221 temp = dims[i];
01222 dims[i] = dims[j];
01223 dims[j] = temp;
01224 diffs++;
01225 }
01226 }
01227 if (0 == diffs) {
01228 H5Dclose(did);
01229 return;
01230 }
01231 #if 0
01232
01233 bytes = H5Dget_storage_size(did);
01234 tid = H5Dget_type(did);
01235 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
01236 if (bytes > 0) {
01237 data = malloc ((unsigned)bytes);
01238 H5Dread(did, mid, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
01239 }
01240 H5Dclose(did);
01241 H5Gunlink(hid, D_DATA);
01242
01243
01244 sid = H5Screate_simple(ndims, dims, NULL);
01245 did = H5Dcreate2(hid, D_DATA, tid, sid, H5P_DEFAULT, mta_root->g_propdataset, H5P_DEFAULT);
01246 if (data != NULL) {
01247 H5Dwrite(did, mid, H5S_ALL, sid, H5P_DEFAULT, data);
01248 free(data);
01249 }
01250 H5Tclose(mid);
01251 H5Tclose(tid);
01252 H5Sclose(sid);
01253 #else
01254 if (H5Dset_extent(did, dims) < 0) {
01255 fprintf(stderr, "H5Dset_extent failed\n");
01256 }
01257 #endif
01258 H5Dclose(did);
01259 }
01260
01261
01262
01263 static herr_t fix_dimensions(hid_t id, const char *name, void *data)
01264 {
01265 hid_t gid;
01266 int err;
01267 char type[ADF_DATA_TYPE_LENGTH+1];
01268
01269 if (*name != D_PREFIX && (gid = H5Gopen2(id, name, H5P_DEFAULT)) >= 0 &&
01270 !get_str_att(gid, A_TYPE, type, &err) && strcmp(type, ADFH_LK)) {
01271 H5Giterate(gid, ".", NULL, fix_dimensions, NULL);
01272 transpose_dimensions(gid,name);
01273 H5Gclose(gid);
01274 }
01275 return 0;
01276 }
01277
01278 #endif
01279
01280
01281
01282
01283
01284
01285
01286
01287 void ADFH_Move_Child(const double pid,
01288 const double id,
01289 const double npid,
01290 int *err)
01291 {
01292 hid_t hpid = to_HDF_ID(pid);
01293 hid_t hid = to_HDF_ID(id);
01294 hid_t hnpid = to_HDF_ID(npid);
01295 int len, namelen;
01296 int old_order, new_order;
01297 char buff[2];
01298 char nodename[ADF_NAME_LENGTH+1];
01299 char *newpath;
01300 herr_t status;
01301 H5G_stat_t stat;
01302
01303 ADFH_DEBUG(("ADFH_Move_Child"));
01304
01305 if (is_link(hpid) || is_link(hnpid)) {
01306 set_error(ADFH_ERR_LINK_MOVE, err);
01307 return;
01308 }
01309
01310
01311
01312 if (H5Gget_objinfo(hid, ".", 0, &stat) < 0 ||
01313 !H5Giterate(hpid, ".", NULL, compare_children, (void *)&stat)) {
01314 set_error(CHILD_NOT_OF_GIVEN_PARENT, err);
01315 return;
01316 }
01317
01318
01319
01320 if (get_str_att(hid, A_NAME, nodename, err)) return;
01321 namelen = strlen(nodename);
01322
01323
01324
01325 len = H5Iget_name(hnpid, buff, 2);
01326 if (len <= 0) {
01327 set_error(ADFH_ERR_IGET_NAME, err);
01328 return;
01329 }
01330 newpath = (char *) malloc (len+namelen+2);
01331 if (newpath == NULL) {
01332 set_error(MEMORY_ALLOCATION_FAILED, err);
01333 return;
01334 }
01335 H5Iget_name(hnpid, newpath, len+1);
01336 newpath[len++] = '/';
01337 strcpy(&newpath[len], nodename);
01338
01339 #ifdef ADFH_DEBUG_ON
01340 printf("%s move [%s]\n",ADFH_PREFIX,nodename);
01341 printf("%s to [%s]\n",ADFH_PREFIX,newpath);
01342 #endif
01343
01344 status = H5Gmove(hpid, nodename, newpath);
01345 free(newpath);
01346 if (status < 0) {
01347 set_error(ADFH_ERR_GMOVE, err);
01348 return;
01349 }
01350
01351 #ifdef ADFH_NO_ORDER
01352 set_error(NO_ERROR, err);
01353 #else
01354
01355 ADFH_Number_of_Children(npid, &new_order, err);
01356 if (*err != NO_ERROR) return;
01357
01358
01359 if (get_int_att(hid, A_ORDER, &old_order, err) ||
01360 set_int_att(hid, A_ORDER, new_order, err)) return;
01361
01362
01363 *err = H5Giterate(hpid, ".", NULL, fix_order, (void *)&old_order);
01364 if (!*err)
01365 set_error(NO_ERROR, err);
01366 #endif
01367 }
01368
01369
01370
01371
01372 void ADFH_Set_Label(const double id,
01373 const char *label,
01374 int *err)
01375 {
01376 hid_t hid = to_HDF_ID(id);
01377
01378 ADFH_DEBUG(("ADFH_Set_Label [%s]",label));
01379
01380 if (label == NULL) {
01381 set_error(NULL_STRING_POINTER, err);
01382 return;
01383 }
01384 if (strlen(label) > ADF_NAME_LENGTH) {
01385 set_error(STRING_LENGTH_TOO_BIG, err);
01386 return;
01387 }
01388 if (is_link(hid)) {
01389 set_error(ADFH_ERR_LINK_DATA, err);
01390 return;
01391 }
01392 set_str_att(hid, A_LABEL, label, err);
01393 }
01394
01395
01396
01397
01398 void ADFH_Put_Name(const double pid,
01399 const double id,
01400 const char *name,
01401 int *err)
01402 {
01403 hid_t hpid = to_HDF_ID(pid);
01404 hid_t hid = to_HDF_ID(id);
01405 char *nname, oname[ADF_NAME_LENGTH+1];
01406
01407 ADFH_DEBUG(("ADFH_Put_Name [%s]",name));
01408
01409 if ((nname = check_name(name, err)) == NULL) return;
01410 if (is_link(hpid)) {
01411 set_error(ADFH_ERR_LINK_DATA, err);
01412 return;
01413 }
01414 if (has_child(hpid, nname)) {
01415 set_error(DUPLICATE_CHILD_NAME, err);
01416 return;
01417 }
01418 if (!get_str_att(hid, A_NAME, oname, err)) {
01419 #ifdef ADFH_DEBUG_ON
01420 printf("%s change [%s] to [%s]\n",ADFH_PREFIX,oname,nname);
01421 #endif
01422 if (H5Gmove(hpid, oname, nname) < 0)
01423 set_error(ADFH_ERR_GMOVE, err);
01424 else
01425 set_str_att(hid, A_NAME, nname, err);
01426 }
01427 }
01428
01429
01430
01431
01432 void ADFH_Get_Name(const double id,
01433 char *name,
01434 int *err)
01435 {
01436 hid_t hid = to_HDF_ID(id);
01437 char buffname[ADF_NAME_LENGTH+1];
01438
01439 ADFH_DEBUG((">ADFH_Get_Name"));
01440
01441 if (name == NULL) {
01442 set_error(NULL_STRING_POINTER, err);
01443 return;
01444 }
01445 get_str_att(hid, A_NAME, buffname, err);
01446 strcpy(name,buffname);
01447
01448 ADFH_DEBUG(("<ADFH_Get_Name [%s]",name));
01449
01450 }
01451
01452
01453
01454
01455 void ADFH_Get_Label(const double id,
01456 char *label,
01457 int *err)
01458 {
01459 hid_t hid;
01460 H5G_stat_t sb;
01461 char bufflabel[ADF_LABEL_LENGTH+1];
01462
01463 ADFH_DEBUG((">ADFH_Get_Label"));
01464
01465 if (label == NULL) {
01466 set_error(NULL_STRING_POINTER, err);
01467 return;
01468 }
01469
01470 if ((hid = open_node(id, err)) >= 0)
01471 {
01472 get_str_att(hid, A_LABEL, bufflabel, err);
01473 if (H5Gclose(hid)<0)
01474 {
01475 ADFH_DEBUG((">ADFH H5Gclose failed (G)"));
01476 }
01477 }
01478 strcpy(label,bufflabel);
01479 ADFH_DEBUG(("<ADFH_Get_Label"));
01480 }
01481
01482
01483
01484
01485
01486
01487
01488 void ADFH_Create(const double pid,
01489 const char *name,
01490 double *id,
01491 int *err)
01492 {
01493 hid_t hpid = to_HDF_ID(pid);
01494 hid_t gid,fid;
01495 int order;
01496 char *pname;
01497
01498 ADFH_DEBUG((">ADFH_Create [%s]",name));
01499
01500 if ((pname = check_name(name, err)) == NULL) return;
01501 if (id == NULL) {
01502 set_error(NULL_NODEID_POINTER, err);
01503 return;
01504 }
01505
01506
01507
01508
01509
01510
01511 if (has_child(hpid, pname)) {
01512 set_error(DUPLICATE_CHILD_NAME, err);
01513 return;
01514 }
01515
01516 *id = 0;
01517 gid = H5Gcreate2(hpid, pname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
01518
01519 if (gid < 0)
01520 set_error(ADFH_ERR_GCREATE, err);
01521 else {
01522 #ifdef ADFH_NO_ORDER
01523 if (new_str_att(gid, A_NAME, pname, ADF_NAME_LENGTH, err) ||
01524 new_str_att(gid, A_LABEL, "", ADF_NAME_LENGTH, err) ||
01525 new_str_att(gid, A_TYPE, ADFH_MT, 2, err) ||
01526
01527 new_int_att(gid, A_FLAGS, mta_root->g_flags, err)) return;
01528 #else
01529 order = 0;
01530 H5Giterate(hpid, ".", NULL, count_children, (void *)&order);
01531 if (new_str_att(gid, A_NAME, pname, ADF_NAME_LENGTH, err) ||
01532 new_str_att(gid, A_LABEL, "", ADF_NAME_LENGTH, err) ||
01533 new_str_att(gid, A_TYPE, ADFH_MT, 2, err) ||
01534 new_int_att(gid, A_ORDER, order, err) ||
01535
01536 new_int_att(gid, A_FLAGS, mta_root->g_flags, err)) return;
01537 #endif
01538 *id = to_ADF_ID(gid);
01539 ADFH_DEBUG(("<ADFH_Create [%s]",name));
01540 }
01541 }
01542
01543
01544
01545
01546 void ADFH_Delete(const double pid,
01547 const double id,
01548 int *err)
01549 {
01550 hid_t hpid = to_HDF_ID(pid);
01551 hid_t hid = to_HDF_ID(id);
01552 char old_name[ADF_NAME_LENGTH+1];
01553 int old_order;
01554 H5G_stat_t stat;
01555
01556 ADFH_DEBUG(("ADFH_Delete"));
01557
01558 if (is_link(hpid)) {
01559 set_error(ADFH_ERR_LINK_DELETE, err);
01560 return;
01561 }
01562
01563
01564
01565 if (H5Gget_objinfo(hid, ".", 0, &stat) < 0 ||
01566 !H5Giterate(hpid, ".", NULL, compare_children, (void *)&stat)) {
01567 set_error(CHILD_NOT_OF_GIVEN_PARENT, err);
01568 return;
01569 }
01570
01571
01572
01573 #ifdef ADFH_NO_ORDER
01574 if (get_str_att(hid, A_NAME, old_name, err)) return;
01575 #else
01576 if (get_str_att(hid, A_NAME, old_name, err) ||
01577 get_int_att(hid, A_ORDER, &old_order, err)) return;
01578 #endif
01579
01580
01581
01582 if (! is_link(hid))
01583 {
01584 H5Giterate(hid, ".", NULL, delete_children, NULL);
01585 }
01586
01587
01588
01589 H5Gclose(hid);
01590 delete_node(hpid, old_name);
01591
01592
01593
01594 #ifndef ADFH_NO_ORDER
01595 *err = H5Giterate(hpid, ".", NULL, fix_order, (void *)&old_order);
01596 if (!*err)
01597 #endif
01598 set_error(NO_ERROR, err);
01599 }
01600
01601
01602
01603 void ADFH_Number_of_Children(const double id,
01604 int *number,
01605 int *err)
01606 {
01607 hid_t hid;
01608 int nn,gskip=0;
01609
01610 ADFH_DEBUG((">ADFH_Number_of_Children"));
01611
01612 if (number == NULL) {
01613 set_error(NULL_POINTER, err);
01614 return;
01615 }
01616
01617 *number = 0;
01618 if ((hid = open_node(id, err)) >= 0) {
01619 H5Giterate(hid, ".", &gskip, count_children, (void*)number);
01620 H5Gclose(hid);
01621 }
01622 nn=*number;
01623 ADFH_DEBUG(("<ADFH_Number_of_Children [%d]",nn));
01624 }
01625
01626
01627
01628 void ADFH_Get_Node_ID(const double pid,
01629 const char *name,
01630 double *id,
01631 int *err)
01632 {
01633 hid_t sid, hpid = to_HDF_ID(pid);
01634 herr_t herr;
01635
01636 ADFH_DEBUG((">ADFH_Get_Node_ID [%s]",name));
01637
01638 if (name == NULL) {
01639 set_error(NULL_STRING_POINTER, err);
01640 return;
01641 }
01642 if (id == NULL) {
01643 set_error(NULL_NODEID_POINTER, err);
01644 return;
01645 }
01646
01647 *id = 0;
01648 set_error(NO_ERROR, err);
01649 if (*name == '/') {
01650 hid_t rid;
01651 char *path = (char *) malloc (strlen(name));
01652 if (path == NULL) {
01653 set_error(MEMORY_ALLOCATION_FAILED, err);
01654 return;
01655 }
01656 strcpy(path, &name[1]);
01657 rid = H5Gopen2(hpid, "/", H5P_DEFAULT);
01658 sid = parse_path(rid, path, err);
01659 H5Gclose(rid);
01660 free(path);
01661 }
01662 else if (is_link(hpid)) {
01663 hid_t lid = open_link(hpid, err);
01664 if (lid < 0) return;
01665 sid = H5Gopen2(lid, name, H5P_DEFAULT);
01666 ADFH_CHECK_HID(sid);
01667 H5Gclose(lid);
01668 if(sid < 0)
01669 {
01670 set_error(ADFH_ERR_GOPEN, err);
01671 }
01672 }
01673 else {
01674 sid = H5Gopen2(hpid, name, H5P_DEFAULT);
01675 if(sid < 0)
01676 {
01677 set_error(ADFH_ERR_GOPEN, err);
01678 }
01679 }
01680 *id = to_ADF_ID(sid);
01681 ADFH_DEBUG(("<ADFH_Get_Node_ID [%s]",name));
01682 }
01683
01684
01685
01686 void ADFH_Children_Names(const double pid,
01687 const int istart,
01688 const int ilen,
01689 const int name_length,
01690 int *ilen_ret,
01691 char *names,
01692 int *err)
01693 {
01694 int i, ret;
01695 hid_t hpid;
01696
01697 ADFH_DEBUG(("ADFH_Children_Names"));
01698
01699 ROOT_OR_DIE(err);
01700 if (ilen_ret == NULL) {
01701 set_error(NULL_POINTER, err);
01702 return;
01703 }
01704 if (names == NULL) {
01705 set_error(NULL_STRING_POINTER, err);
01706 return;
01707 }
01708
01709 mta_root->i_start = istart;
01710 mta_root->i_len = ilen;
01711 mta_root->n_length = name_length;
01712 mta_root->n_names = 0;
01713 #ifdef ADFH_NO_ORDER
01714 mta_root->i_count = 0;
01715 #endif
01716
01717
01718 memset(names, 0, ilen*name_length);
01719
01720 if ((hpid = open_node(pid, err)) >= 0) {
01721 H5Giterate(hpid, ".", NULL, children_names, (void *)names);
01722 H5Gclose(hpid);
01723 }
01724 *ilen_ret = mta_root->n_names;
01725 }
01726
01727
01728
01729 void ADFH_Children_IDs(const double pid,
01730 const int istart,
01731 const int icount,
01732 int *icount_ret,
01733 double *IDs,
01734 int *err)
01735 {
01736 int ret;
01737 hid_t hpid;
01738
01739 ADFH_DEBUG(("ADFH_Children_IDs"));
01740
01741 ROOT_OR_DIE(err);
01742 if (icount_ret == NULL) {
01743 set_error(NULL_POINTER, err);
01744 return;
01745 }
01746 if (IDs == NULL) {
01747 set_error(NULL_NODEID_POINTER, err);
01748 return;
01749 }
01750
01751 mta_root->i_start = istart;
01752 mta_root->i_len = icount;
01753 mta_root->n_names = 0;
01754 #ifdef ADFH_NO_ORDER
01755 mta_root->i_count = 0;
01756 #endif
01757
01758 if ((hpid = open_node(pid, err)) >= 0) {
01759 H5Giterate(hpid, ".", NULL, children_ids, (void *)IDs);
01760 H5Gclose(hpid);
01761 }
01762 *icount_ret = mta_root->n_names;
01763 }
01764
01765
01766
01767 void ADFH_Release_ID(const double ID)
01768 {
01769 ADFH_DEBUG(("ADFH_Release_ID"));
01770
01771 H5Gclose(to_HDF_ID(ID));
01772 }
01773
01774
01775
01776 void ADFH_Database_Open(const char *name,
01777 const char *stat,
01778 const char *fmt,
01779 double *root,
01780 int *err)
01781 {
01782 hid_t fid, gid, fapl;
01783 char *format, buff[ADF_VERSION_LENGTH+1];
01784 int i, pos, mode;
01785
01786 ADFH_DEBUG(("ADFH_Database_Open [%s]",name));
01787
01788
01789 if (mta_root==NULL)
01790 {
01791 mta_root=(ADFH_MTA*)malloc(sizeof(struct _ADFH_MTA));
01792 mta_root->g_init = 0;
01793 }
01794 mta_root->g_error_state = 0;
01795
01796
01797
01798
01799 mta_root->g_flags = 1;
01800
01801 #ifndef ADF_DEBUG_ON
01802 H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
01803 #endif
01804 if (!mta_root->g_init) {
01805 #ifndef ADF_DEBUG_ON
01806 H5Eset_auto2(H5E_DEFAULT, walk_H5_error, NULL);
01807 #endif
01808 for (i = 0; i < ADFH_MAXIMUM_FILES; i++) mta_root->g_files[i] = 0;
01809 mta_root->g_init = 1;
01810 }
01811
01812 if (name == NULL || stat == NULL || fmt == NULL) {
01813 set_error(NULL_STRING_POINTER, err);
01814 return;
01815 }
01816
01817
01818
01819 strncpy(buff, stat, 9);
01820 buff[9] = 0;
01821 for (i = 0; buff[i]; i++)
01822 buff[i] = TO_UPPER(buff[i]);
01823
01824 if (0 == strcmp(buff, "UNKNOWN")) {
01825 if (access(name, 0))
01826 mode = ADFH_MODE_NEW;
01827 else if (access(name, 2))
01828 mode = ADFH_MODE_RDO;
01829 else
01830 mode = ADFH_MODE_OLD;
01831 }
01832 else if (0 == strcmp(buff, "NEW")) {
01833 if (!access(name, 0)) {
01834 set_error(REQUESTED_NEW_FILE_EXISTS, err);
01835 return;
01836 }
01837 mode = ADFH_MODE_NEW;
01838 }
01839 else if (0 == strcmp(buff, "READ_ONLY")) {
01840 if (access(name, 0)) {
01841 set_error(REQUESTED_OLD_FILE_NOT_FOUND, err);
01842 return;
01843 }
01844 mode = ADFH_MODE_RDO;
01845 }
01846 else if (0 == strcmp(buff, "OLD")) {
01847 if (access(name, 0)) {
01848 set_error(REQUESTED_OLD_FILE_NOT_FOUND, err);
01849 return;
01850 }
01851 mode = ADFH_MODE_OLD;
01852 }
01853 else {
01854 set_error(ADF_FILE_STATUS_NOT_RECOGNIZED, err);
01855 return;
01856 }
01857
01858
01859
01860 #if 0
01861 if (mode == ADFH_MODE_NEW) {
01862 strncpy(buff, fmt, 11);
01863 buff[11] = 0;
01864 for (i = 0; buff[i]; i++)
01865 buff[i] = TO_UPPER(buff[i]);
01866
01867 if (strcmp(buff, "NATIVE") &&
01868 strncmp(buff, "IEEE_BIG", 8) &&
01869 strcmp(buff, "IEEE_LITTLE", 11) &&
01870 strcmp(buff, "CRAY")) {
01871 set_error(ADF_FILE_FORMAT_NOT_RECOGNIZED, err);
01872 return;
01873 }
01874 }
01875 #endif
01876
01877
01878
01879 for (pos = 0; pos < ADFH_MAXIMUM_FILES; pos++) {
01880 if (mta_root->g_files[pos] == 0) break;
01881 }
01882 if (pos == ADFH_MAXIMUM_FILES) {
01883 set_error(TOO_MANY_ADF_FILES_OPENED, err);
01884 return;
01885 }
01886
01887
01888 mta_root->g_propfile = H5Pcreate(H5P_FILE_ACCESS);
01889 H5Pset_fclose_degree(mta_root->g_propfile, H5F_CLOSE_STRONG);
01890
01891
01892 H5Pset_libver_bounds(mta_root->g_propfile, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST);
01893
01894
01895 mta_root->g_proplink=H5Pcreate(H5P_LINK_ACCESS);
01896 H5Pset_nlinks(mta_root->g_proplink, ADF_MAXIMUM_LINK_DEPTH);
01897 mta_root->g_propdataset=H5Pcreate(H5P_DATASET_CREATE);
01898
01899
01900
01901 set_error(NO_ERROR, err);
01902
01903 if (mode == ADFH_MODE_NEW) {
01904 fid = H5Fcreate(name, H5F_ACC_TRUNC, H5P_DEFAULT, mta_root->g_propfile);
01905 if (fid < 0) {
01906 H5Pclose(mta_root->g_propfile);
01907 set_error(FILE_OPEN_ERROR, err);
01908 return;
01909 }
01910 gid = H5Gopen2(fid, "/", H5P_DEFAULT);
01911 memset(buff, 0, ADF_VERSION_LENGTH+1);
01912 ADFH_Library_Version(buff, err);
01913 format = native_format();
01914 if (new_str_att(gid, A_NAME, "HDF5 MotherNode", ADF_NAME_LENGTH, err) ||
01915 new_str_att(gid, A_LABEL, "Root Node of HDF5 File", ADF_NAME_LENGTH, err) ||
01916 new_str_att(gid, A_TYPE, ADFH_MT, 2, err) ||
01917 new_str_data(gid, D_FORMAT, format, strlen(format), err) ||
01918 new_str_data(gid, D_VERSION, buff, ADF_VERSION_LENGTH, err)) {
01919 H5Gclose(gid);
01920 return;
01921 }
01922 }
01923 else {
01924 if (H5Fis_hdf5(name) <= 0) {
01925 H5Pclose(mta_root->g_propfile);
01926 set_error(ADFH_ERR_NOT_HDF5_FILE, err);
01927 return;
01928 }
01929 if (mode == ADFH_MODE_RDO)
01930 {
01931 fid = H5Fopen(name, H5F_ACC_RDONLY, mta_root->g_propfile);
01932 }
01933 else
01934 {
01935 fid = H5Fopen(name, H5F_ACC_RDWR, mta_root->g_propfile);
01936 }
01937 H5Pclose(mta_root->g_propfile);
01938 if (fid < 0) {
01939 set_error(FILE_OPEN_ERROR, err);
01940 return;
01941 }
01942 gid = H5Gopen2(fid, "/", H5P_DEFAULT);
01943 #ifdef ADFH_FORTRAN_INDEXING
01944 if (mode != ADFH_MODE_RDO && has_child(gid, D_OLDVERS)) {
01945 H5Giterate(gid, ".", NULL, fix_dimensions, NULL);
01946 H5Gmove(gid, D_OLDVERS, D_VERSION);
01947 }
01948 #endif
01949 }
01950
01951 mta_root->g_files[pos] = fid;
01952
01953
01954 *root = to_ADF_ID(gid);
01955 }
01956
01957
01958
01959 void ADFH_Database_Valid(const char *name,
01960 int *err)
01961 {
01962 if (NULL == name || 0 == *name)
01963 *err = NULL_STRING_POINTER;
01964 else
01965 *err = H5Fis_hdf5(name);
01966 }
01967
01968
01969
01970 void ADFH_Database_Get_Format(const double rootid,
01971 char *format,
01972 int *err)
01973 {
01974 char node[ADF_NAME_LENGTH+1];
01975 hid_t did;
01976 herr_t status;
01977
01978 ADFH_DEBUG(("ADFH_Database_Get_Format"));
01979
01980 if (format == NULL) {
01981 set_error(NULL_STRING_POINTER, err);
01982 return;
01983 }
01984 *format = 0;
01985 set_error(NO_ERROR, err);
01986
01987 sprintf(node, "/%s", D_FORMAT);
01988 if ((did = H5Dopen2(to_HDF_ID(rootid), node, H5P_DEFAULT)) < 0) {
01989 set_error(ADFH_ERR_DOPEN, err);
01990 return;
01991 }
01992 status = H5Dread(did, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, H5P_DEFAULT, format);
01993 H5Dclose(did);
01994
01995 if (status < 0)
01996 set_error(ADFH_ERR_DREAD, err);
01997 }
01998
01999
02000
02001 void ADFH_Database_Set_Format(const double rootid,
02002 const char *format,
02003 int *err)
02004 {
02005 ADFH_DEBUG(("ADFH_Database_Set_Format"));
02006 set_error(ADFH_ERR_NOT_IMPLEMENTED, err);
02007 }
02008
02009
02010
02011 void ADFH_Database_Delete(const char *name,
02012 int *err)
02013 {
02014 ADFH_DEBUG(("ADFH_Database_Delete [%s]",name));
02015
02016 if (H5Fis_hdf5(name) <= 0)
02017 set_error(ADFH_ERR_NOT_HDF5_FILE, err);
02018 else if (unlink(name))
02019 set_error(ADFH_ERR_FILE_DELETE, err);
02020 else
02021 set_error(NO_ERROR, err);
02022 }
02023
02024
02025
02026 void ADFH_Database_Close(const double root,
02027 int *status)
02028 {
02029 int n,idx;
02030 hid_t fid, mid;
02031 #ifdef ADFH_FORCE_ID_CLOSE
02032 int nobj;
02033 hid_t *objs;
02034 #endif
02035
02036 ADFH_DEBUG(("ADFH_Database_Close"));
02037 if (mta_root == NULL)
02038 {
02039 ADFH_DEBUG(("ADFH_Database_Close [mta is null]"));
02040 return;
02041 }
02042 ADFH_DEBUG(("ADFH_Database_Close 4"));
02043 if ((n = get_file_number(to_HDF_ID(root), status)) < 0) return;
02044 fid = mta_root->g_files[n];
02045 mta_root->g_files[n] = 0;
02046
02047 ADFH_DEBUG(("ADFH_Database_Close 3"));
02048
02049
02050 #ifdef ADFH_FORCE_ID_CLOSE
02051 nobj = H5Fget_obj_count(fid, H5F_OBJ_ALL);
02052 objs = (hid_t *) malloc (nobj * sizeof(hid_t));
02053
02054
02055
02056 nobj = H5Fget_obj_count(fid, H5F_OBJ_DATATYPE);
02057 #ifdef ADFH_DEBUG_ON
02058 printf("%s close DataType [%d] HIDs\n",ADFH_PREFIX,nobj);
02059 #endif
02060 if (nobj) {
02061 H5Fget_obj_ids(fid, H5F_OBJ_DATATYPE, -1, objs);
02062 for (n = 0; n < nobj; n++)
02063 H5Tclose(objs[n]);
02064 }
02065
02066
02067
02068 nobj = H5Fget_obj_count(fid, H5F_OBJ_DATASET);
02069 #ifdef ADFH_DEBUG_ON
02070 printf("%s close DataSet [%d] HIDs\n",ADFH_PREFIX,nobj);
02071 #endif
02072 if (nobj) {
02073 H5Fget_obj_ids(fid, H5F_OBJ_DATASET, -1, objs);
02074 for (n = 0; n < nobj; n++)
02075 H5Dclose(objs[n]);
02076 }
02077
02078
02079
02080 nobj = H5Fget_obj_count(fid, H5F_OBJ_ATTR);
02081 #ifdef ADFH_DEBUG_ON
02082 printf("%s close Attr [%d] HIDs\n",ADFH_PREFIX,nobj);
02083 #endif
02084 if (nobj) {
02085 H5Fget_obj_ids(fid, H5F_OBJ_ATTR, -1, objs);
02086 for (n = 0; n < nobj; n++)
02087 H5Aclose(objs[n]);
02088 }
02089
02090
02091
02092 nobj = H5Fget_obj_count(fid, H5F_OBJ_GROUP);
02093 #ifdef ADFH_DEBUG_ON
02094 printf("%s close Group [%d] HIDs\n",ADFH_PREFIX,nobj);
02095 #endif
02096 if (nobj) {
02097 H5Fget_obj_ids(fid, H5F_OBJ_GROUP, -1, objs);
02098 for (n = 0; n < nobj; n++)
02099 {
02100 H5Gclose(objs[n]);
02101 }
02102 }
02103
02104 #if 0
02105
02106
02107 nobj = H5Fget_obj_count(fid, H5F_OBJ_FILE);
02108 if (nobj) {
02109 H5Fget_obj_ids(fid, H5F_OBJ_FILE, -1, objs);
02110 for (n = 0; n < nobj; n++) {
02111 if (objs[n] != fid)
02112 H5Fclose(objs[n]);
02113 }
02114 }
02115 #endif
02116
02117 free (objs);
02118 #endif
02119
02120 ADFH_DEBUG(("ADFH_Database_Close 2"));
02121 H5Pclose(mta_root->g_proplink);
02122 H5Pclose(mta_root->g_propdataset);
02123
02124
02125 if (H5Fclose(fid) < 0)
02126 set_error(FILE_CLOSE_ERROR, status);
02127 else
02128 set_error(NO_ERROR, status);
02129
02130 ADFH_DEBUG(("ADFH_Database_Close 1"));
02131 if (mta_root != NULL)
02132 {
02133 idx=0;
02134 for (n = 0; n < ADFH_MAXIMUM_FILES; n++) idx+=mta_root->g_files[n];
02135 if (! idx)
02136 {
02137 free(mta_root);
02138 mta_root=NULL;
02139 }
02140 }
02141 ADFH_DEBUG(("ADFH_Database_Close 0"));
02142 }
02143
02144
02145
02146 void ADFH_Is_Link(const double id,
02147 int *link_path_length,
02148 int *err)
02149 {
02150 hid_t hid = to_HDF_ID(id);
02151
02152 ADFH_DEBUG(("ADFH_Is_Link"));
02153
02154 if (is_link(hid)) {
02155 hid_t did, sid;
02156 hsize_t size;
02157
02158 did = H5Dopen2(hid, D_PATH, H5P_DEFAULT);
02159 ADFH_CHECK_HID(did);
02160 sid = H5Dget_space(did);
02161 ADFH_CHECK_HID(sid);
02162 size = H5Sget_simple_extent_npoints(sid);
02163 H5Sclose(sid);
02164 H5Dclose(did);
02165 *link_path_length = (int)size;
02166
02167 if (has_child(hid, D_FILE)) {
02168 did = H5Dopen2(hid, D_FILE, H5P_DEFAULT);
02169 ADFH_CHECK_HID(did);
02170 sid = H5Dget_space(did);
02171 ADFH_CHECK_HID(sid);
02172 size = H5Sget_simple_extent_npoints(sid);
02173 H5Sclose(sid);
02174 H5Dclose(did);
02175 *link_path_length += (int)size;
02176 }
02177 }
02178 else
02179 *link_path_length = 0;
02180 set_error(NO_ERROR, err);
02181 }
02182
02183
02184
02185 void ADFH_Link_Size(const double id,
02186 int *file_len,
02187 int *name_len,
02188 int *err)
02189 {
02190 hid_t hid = to_HDF_ID(id);
02191
02192 ADFH_DEBUG(("ADFH_Link_Size"));
02193
02194 *name_len = *file_len = 0;
02195 if (is_link(hid)) {
02196 hid_t did, sid;
02197 hsize_t size;
02198
02199 did = H5Dopen2(hid, D_PATH, H5P_DEFAULT);
02200 sid = H5Dget_space(did);
02201 size = H5Sget_simple_extent_npoints(sid);
02202 H5Sclose(sid);
02203 H5Dclose(did);
02204 *name_len = (int)size;
02205
02206 if (has_child(hid, D_FILE)) {
02207 did = H5Dopen2(hid, D_FILE, H5P_DEFAULT);
02208 sid = H5Dget_space(did);
02209 size = H5Sget_simple_extent_npoints(sid);
02210 H5Sclose(sid);
02211 H5Dclose(did);
02212 *file_len = (int)size;
02213 }
02214 }
02215 set_error(NO_ERROR, err);
02216 }
02217
02218
02219
02220 void ADFH_Get_Root_ID(const double id,
02221 double *root_id,
02222 int *err)
02223 {
02224 hid_t rid;
02225
02226 ADFH_DEBUG(("ADFH_Get_Root_ID"));
02227
02228 rid = H5Gopen2(to_HDF_ID(id), "/", H5P_DEFAULT);
02229 if (rid < 0)
02230 set_error(ADFH_ERR_GOPEN, err);
02231 else {
02232 *root_id = to_ADF_ID(rid);
02233 set_error(NO_ERROR, err);
02234 }
02235 }
02236
02237
02238
02239 void ADFH_Get_Data_Type(const double id,
02240 char *data_type,
02241 int *err)
02242 {
02243 hid_t hid;
02244 char buffdata_type[3];
02245
02246 ADFH_DEBUG(("ADFH_Get_Data_Type"));
02247
02248 if ((hid = open_node(id, err)) >= 0) {
02249 get_str_att(hid, A_TYPE, buffdata_type, err);
02250 H5Gclose(hid);
02251 strcpy(data_type,buffdata_type);
02252 }
02253 }
02254
02255
02256
02257 void ADFH_Get_Number_of_Dimensions(const double id,
02258 int *num_dims,
02259 int *err)
02260 {
02261 hid_t hid, did, sid;
02262 char type[3];
02263
02264 ADFH_DEBUG(("ADFH_Get_Number_of_Dimensions"));
02265
02266 *num_dims = 0;
02267 if ((hid = open_node(id, err)) < 0) return;
02268 if (get_str_att(hid, A_TYPE, type, err) ||
02269 0 == strcmp(type, ADFH_MT) || 0 == strcmp(type, ADFH_LK)) {
02270 H5Gclose(hid);
02271 return;
02272 }
02273
02274 if ((did = H5Dopen2(hid, D_DATA, H5P_DEFAULT)) < 0)
02275 set_error(NO_DATA, err);
02276 else {
02277 if ((sid = H5Dget_space(did)) < 0)
02278 set_error(ADFH_ERR_DGET_SPACE, err);
02279 else {
02280 *num_dims = H5Sget_simple_extent_ndims(sid);
02281 H5Sclose(sid);
02282 }
02283 H5Dclose(did);
02284 }
02285 H5Gclose(hid);
02286 }
02287
02288
02289
02290 void ADFH_Get_Dimension_Values(const double id,
02291 int dim_vals[],
02292 int *err)
02293 {
02294 int i, ndims, swap = 0;
02295 hid_t hid, did, sid;
02296 hsize_t temp_vals[ADF_MAX_DIMENSIONS];
02297 herr_t status;
02298
02299 ADFH_DEBUG(("ADFH_Get_Dimension_Values"));
02300
02301 ndims=0;
02302 dim_vals[0]=0;
02303 if ((hid = open_node(id, err)) < 0) return;
02304 if ((did = H5Dopen2(hid, D_DATA, H5P_DEFAULT)) < 0)
02305 set_error(NO_DATA, err);
02306 else {
02307 if ((sid = H5Dget_space(did)) < 0)
02308 set_error(ADFH_ERR_DGET_SPACE, err);
02309 else {
02310 ndims = H5Sget_simple_extent_ndims(sid);
02311 if (ndims > 0) {
02312 H5Sget_simple_extent_dims(sid, temp_vals, NULL);
02313 #ifdef ADFH_FORTRAN_INDEXING
02314 if (ndims > 1) swap = swap_dimensions(hid);
02315 #endif
02316 if (swap) {
02317 for (i = 0; i < ndims; i++)
02318 dim_vals[i] = (int)temp_vals[ndims-1-i];
02319 }
02320 else {
02321 for (i = 0; i < ndims; i++)
02322 dim_vals[i] = (int)temp_vals[i];
02323 }
02324 }
02325 H5Sclose(sid);
02326 }
02327 H5Dclose(did);
02328 }
02329 H5Gclose(hid);
02330 }
02331
02332
02333
02334 void ADFH_Put_Dimension_Information(const double id,
02335 const char *data_type,
02336 const int dims,
02337 const int dim_vals[],
02338 int *err)
02339 {
02340 hid_t hid = to_HDF_ID(id);
02341 hid_t did, tid, sid, mid;
02342 int i, swap = 0;
02343 hsize_t old_size;
02344 hsize_t old_dims[ADF_MAX_DIMENSIONS];
02345 hsize_t new_dims[ADF_MAX_DIMENSIONS];
02346 void *data = NULL;
02347 char old_type[3];
02348 char new_type[3];
02349
02350 ADFH_DEBUG(("ADFH_Put_Dimension_Information"));
02351
02352 if (is_link(hid)) {
02353 set_error(ADFH_ERR_LINK_DATA, err);
02354 return;
02355 }
02356 for (i = 0; i < 2; i++)
02357 new_type[i] = TO_UPPER(data_type[i]);
02358 new_type[2] = 0;
02359
02360 if (0 == strcmp(new_type, ADFH_MT)) {
02361 if (has_data(hid))
02362 H5Gunlink(hid, D_DATA);
02363 set_str_att(hid, A_TYPE, new_type, err);
02364 return;
02365 }
02366
02367 if (check_data_type(new_type, err)) return;
02368 if (dims < 1 || dims > ADF_MAX_DIMENSIONS) {
02369 set_error(BAD_NUMBER_OF_DIMENSIONS, err);
02370 return;
02371 }
02372 for (i = 0; i < dims; i++) {
02373 if (dim_vals[i] < 1) {
02374 set_error(BAD_DIMENSION_VALUE, err);
02375 return;
02376 }
02377 }
02378
02379
02380
02381
02382
02383
02384
02385
02386
02387
02388
02389
02390
02391 old_size = 0;
02392 if(has_data(hid)) {
02393 H5Gunlink(hid, D_DATA);
02394 }
02395
02396 if (set_str_att(hid, A_TYPE, new_type, err)) {
02397 if (data != NULL) free(data);
02398 return;
02399 }
02400
02401
02402
02403 #ifdef ADFH_FORTRAN_INDEXING
02404 if (dims > 1) swap = swap_dimensions(hid);
02405 #endif
02406 if (swap) {
02407 for (i = 0; i < dims; i++)
02408 new_dims[i] = (hsize_t)dim_vals[dims-1-i];
02409 }
02410 else {
02411 for (i = 0; i < dims; i++)
02412 new_dims[i] = (hsize_t)dim_vals[i];
02413 }
02414
02415 tid = to_HDF_data_type(new_type);
02416 ADFH_CHECK_HID(tid);
02417 sid = H5Screate_simple(dims, new_dims, NULL);
02418
02419 #ifdef ADFH_COMPRESS_DATA
02420 if (cgns_compress != -1)
02421 {
02422 H5Pset_deflate(mta_root->g_propdataset, cgns_compress);
02423 }
02424 H5Pset_chunk(mta_root->g_propdataset, dims, new_dims);
02425 #endif
02426 ADFH_CHECK_HID(sid);
02427 did = H5Dcreate2(hid, D_DATA, tid, sid,
02428 H5P_DEFAULT, mta_root->g_propdataset, H5P_DEFAULT);
02429 H5Eprint1(stdout);
02430 ADFH_CHECK_HID(did);
02431
02432 if (did < 0 && data != NULL) {
02433 free(data);
02434 data = NULL;
02435 }
02436
02437
02438
02439 if (data != NULL) {
02440 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
02441 ADFH_CHECK_HID(mid);
02442 if (old_size < H5Dget_storage_size(did))
02443 H5Sset_extent_simple(sid, dims, old_dims, NULL);
02444 H5Dwrite(did, mid, H5S_ALL, sid, H5P_DEFAULT, data);
02445 H5Tclose(mid);
02446 free(data);
02447 }
02448
02449 H5Sclose(sid);
02450 H5Tclose(tid);
02451
02452 if (did < 0)
02453 set_error(ADFH_ERR_DCREATE, err);
02454 else {
02455 H5Dclose(did);
02456 set_error(NO_ERROR, err);
02457 }
02458 }
02459
02460
02461
02462 void ADFH_Get_Link_Path(const double id,
02463 char *filename,
02464 char *link_path,
02465 int *err)
02466 {
02467 hid_t hid, did;
02468 char *mntpath;
02469
02470 ADFH_DEBUG(("ADFH_Get_Link_Path"));
02471
02472 hid = to_HDF_ID(id);
02473 ADFH_CHECK_HID(hid);
02474 if (!is_link(hid)) {
02475 set_error(NODE_IS_NOT_A_LINK, err);
02476 return;
02477 }
02478 did = H5Dopen2(hid, D_PATH, H5P_DEFAULT);
02479 ADFH_CHECK_HID(did);
02480 H5Dread(did, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, H5P_DEFAULT, link_path);
02481 H5Dclose(did);
02482
02483 if (has_child(hid, D_FILE)) {
02484 did = H5Dopen2(hid, D_FILE, H5P_DEFAULT);
02485 ADFH_CHECK_HID(did);
02486 H5Dread(did, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, H5P_DEFAULT, filename);
02487 H5Dclose(did);
02488 }
02489 else
02490 {
02491 *filename = 0;
02492 }
02493 set_error(NO_ERROR, err);
02494 }
02495
02496
02497
02498 void ADFH_Link(const double pid,
02499 const char *name,
02500 const char *file,
02501 const char *name_in_file,
02502 double *id,
02503 int *err)
02504 {
02505 int refcnt, mntnum;
02506 char mntname[32], *target;
02507 herr_t status;
02508 hid_t rid, gid, mid, lid;
02509
02510 ADFH_DEBUG(("ADFH_Link [%s][%s][%s]",name,file,name_in_file));
02511
02512 ROOT_OR_DIE(err);
02513 ADFH_Create(pid, name, id, err);
02514
02515 if (*err != NO_ERROR) return;
02516 lid = to_HDF_ID(*id);
02517 ADFH_CHECK_HID(lid);
02518 if (set_str_att(lid, A_TYPE, ADFH_LK, err)) return;
02519
02520
02521
02522
02523
02524 if (*file) {
02525
02526
02527
02528
02529 H5Lcreate_external(file,
02530 name_in_file,
02531 lid,
02532 D_LINK,
02533 H5P_DEFAULT,
02534 mta_root->g_proplink);
02535 }
02536 else
02537 {
02538 target = (char *) malloc (strlen(name_in_file)+2);
02539 if (target == NULL) {
02540 set_error(MEMORY_ALLOCATION_FAILED, err);
02541 return;
02542 }
02543 if (*name_in_file == '/')
02544 strcpy(target, name_in_file);
02545 else
02546 sprintf(target, "/%s", name_in_file);
02547
02548
02549
02550 status = H5Glink(lid, H5G_LINK_SOFT, target, D_LINK);
02551 free(target);
02552 if (status < 0) {
02553 set_error(ADFH_ERR_GLINK, err);
02554 return;
02555 }
02556 }
02557
02558
02559 if (new_str_data(lid,D_PATH,name_in_file,strlen(name_in_file),err)) return;
02560 if (*file && new_str_data(lid,D_FILE,file,strlen(file),err)) return;
02561
02562 set_error(NO_ERROR, err);
02563 }
02564
02565
02566
02567 void ADFH_Flush_to_Disk(const double id,
02568 int *err)
02569 {
02570 ADFH_DEBUG(("ADFH_Flush_to_Disk"));
02571
02572 if(H5Fflush(to_HDF_ID(id), H5F_SCOPE_LOCAL) >=0 )
02573 set_error(NO_ERROR, err);
02574 else
02575 set_error(FFLUSH_ERROR, err);
02576 }
02577
02578
02579
02580 void ADFH_Database_Garbage_Collection(const double id,
02581 int *err)
02582 {
02583 ADFH_DEBUG(("ADFH_Database_Garbage_Collection"));
02584
02585 if(H5garbage_collect() >= 0)
02586 set_error(NO_ERROR, err);
02587 else
02588 set_error(NO_DATA, err);
02589 }
02590
02591
02592
02593 void ADFH_Database_Version(const double root_id,
02594 char *version,
02595 char *creation_date,
02596 char *modification_date,
02597 int *err)
02598 {
02599 char buff[ADF_VERSION_LENGTH+1];
02600 char node[ADF_NAME_LENGTH+1];
02601 hid_t did;
02602 herr_t status;
02603
02604 ADFH_DEBUG(("ADFH_Database_Version"));
02605
02606 if (version == NULL) {
02607 set_error(NULL_STRING_POINTER, err);
02608 return;
02609 }
02610 *version = 0;
02611 if (creation_date != NULL) *creation_date = 0;
02612 if (modification_date != NULL) *modification_date = 0;
02613 set_error(NO_ERROR, err);
02614
02615 sprintf(node, "/%s", D_VERSION);
02616 if ((did = H5Dopen2(to_HDF_ID(root_id), node, H5P_DEFAULT)) < 0) {
02617 #ifdef ADFH_FORTRAN_INDEXING
02618 sprintf(node, "/%s", D_OLDVERS);
02619 if ((did = H5Dopen2(to_HDF_ID(root_id), node, H5P_DEFAULT)) < 0) {
02620 set_error(ADFH_ERR_DOPEN, err);
02621 return;
02622 }
02623 #else
02624 set_error(ADFH_ERR_DOPEN, err);
02625 return;
02626 #endif
02627 }
02628 status = H5Dread(did, H5T_NATIVE_CHAR, H5S_ALL, H5S_ALL, H5P_DEFAULT, buff);
02629 H5Dclose(did);
02630
02631 if (status < 0)
02632 set_error(ADFH_ERR_DREAD, err);
02633 else
02634 strcpy(version, buff);
02635 }
02636
02637
02638
02639 void ADFH_Library_Version(char *version,
02640 int *err)
02641 {
02642 unsigned maj, min, rel;
02643
02644 ADFH_DEBUG(("ADFH_Library_Version"));
02645
02646 if (version == NULL) {
02647 set_error(NULL_STRING_POINTER, err);
02648 return;
02649 }
02650 H5get_libversion(&maj, &min, &rel);
02651 sprintf(version, "HDF5 Version %d.%d.%d", maj, min, rel);
02652 set_error(NO_ERROR, err);
02653 }
02654
02655
02656
02657 void ADFH_Set_Error_State(const int error_state,
02658 int *error_return)
02659 {
02660 ADFH_DEBUG(("ADFH_Set_Error_State"));
02661
02662 ROOT_OR_DIE(error_return);
02663 mta_root->g_error_state = error_state;
02664 set_error(NO_ERROR, error_return);
02665 }
02666
02667
02668
02669 void ADFH_Error_Message(const int error_return_input,
02670 char *error_string )
02671 {
02672 int i;
02673
02674 ADFH_DEBUG(("ADFH_Error_Message"));
02675
02676 if (error_string == NULL) return;
02677
02678 for (i = 0; i < NUM_ERRORS; i++) {
02679 if (ErrorList[i].errcode == error_return_input) {
02680 strcpy(error_string, ErrorList[i].errmsg);
02681 return;
02682 }
02683 }
02684 sprintf(error_string, "error number %d", error_return_input);
02685 }
02686
02687
02688
02689 void ADFH_Get_Error_State(int *error_state,
02690 int *error_return)
02691 {
02692 ADFH_DEBUG(("ADFH_Get_Error_State"));
02693 ROOT_OR_DIE(error_return);
02694 *error_state = mta_root->g_error_state;
02695 set_error(NO_ERROR, error_return);
02696 }
02697
02698
02699
02700 void ADFH_Read_Block_Data(const double ID,
02701 const long b_start,
02702 const long b_end,
02703 char *data,
02704 int *err )
02705 {
02706 hid_t hid, did, mid, tid, dspace;
02707 size_t size, count, offset;
02708 char *buff;
02709
02710 ADFH_DEBUG(("ADFH_Read_Block_Data"));
02711
02712 if (data == NULL) {
02713 set_error(NULL_POINTER, err);
02714 return;
02715 }
02716 if (b_start > b_end) {
02717 set_error(MINIMUM_GT_MAXIMUM, err);
02718 return;
02719 }
02720 if (b_start < 1) {
02721 set_error(START_OUT_OF_DEFINED_RANGE, err);
02722 return;
02723 }
02724 if ((hid = open_node(ID, err)) < 0) return;
02725
02726 if (!has_data(hid)) {
02727 H5Gclose(hid);
02728 set_error(NO_DATA, err);
02729 return;
02730 }
02731 if ((did = H5Dopen2(hid, D_DATA, H5P_DEFAULT)) < 0) {
02732 H5Gclose(hid);
02733 set_error(ADFH_ERR_DOPEN, err);
02734 return;
02735 }
02736
02737 dspace = H5Dget_space(did);
02738 ADFH_CHECK_HID(dspace);
02739 count = (size_t)H5Sget_simple_extent_npoints(dspace);
02740 H5Sclose(dspace);
02741
02742 if ((size_t)b_end > count) {
02743 H5Dclose(did);
02744 H5Gclose(hid);
02745 set_error(END_OUT_OF_DEFINED_RANGE, err);
02746 return;
02747 }
02748
02749
02750
02751
02752
02753 tid = H5Dget_type(did);
02754 ADFH_CHECK_HID(tid);
02755 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
02756 ADFH_CHECK_HID(mid);
02757 size = H5Tget_size(mid);
02758
02759 if ((buff = (char *) malloc (size * count)) == NULL) {
02760 H5Tclose(mid);
02761 H5Tclose(tid);
02762 H5Dclose(did);
02763 H5Gclose(hid);
02764 set_error(MEMORY_ALLOCATION_FAILED, err);
02765 return;
02766 }
02767
02768 if (H5Dread(did, mid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buff) < 0)
02769 set_error(ADFH_ERR_DREAD, err);
02770 else {
02771 offset = size * (b_start - 1);
02772 count = size * (b_end - b_start + 1);
02773 memcpy(data, &buff[offset], count);
02774 set_error(NO_ERROR, err);
02775 }
02776
02777 free (buff);
02778 H5Tclose(mid);
02779 H5Tclose(tid);
02780 H5Dclose(did);
02781 H5Gclose(hid);
02782 }
02783
02784
02785
02786 void ADFH_Read_Data(const double ID,
02787 const int s_start[],
02788 const int s_end[],
02789 const int s_stride[],
02790 const int m_num_dims,
02791 const int m_dims[],
02792 const int m_start[],
02793 const int m_end[],
02794 const int m_stride[],
02795 char *data,
02796 int *err )
02797 {
02798 int n, ndim;
02799 hid_t hid, did, mid, tid, dspace, mspace;
02800 hsize_t dims[ADF_MAX_DIMENSIONS];
02801 hsize_t start[ADF_MAX_DIMENSIONS];
02802 hsize_t stride[ADF_MAX_DIMENSIONS];
02803 hsize_t count[ADF_MAX_DIMENSIONS];
02804 herr_t status;
02805
02806 ADFH_DEBUG(("ADFH_Read_Data"));
02807
02808 if ((hid = open_node(ID, err)) < 0) return;
02809
02810 if (!has_data(hid)) {
02811 H5Gclose(hid);
02812 set_error(NO_DATA, err);
02813 return;
02814 }
02815 if ((did = H5Dopen2(hid, D_DATA, H5P_DEFAULT)) < 0) {
02816 H5Gclose(hid);
02817 set_error(ADFH_ERR_DOPEN, err);
02818 return;
02819 }
02820
02821
02822
02823 dspace = H5Dget_space(did);
02824 ADFH_CHECK_HID(dspace);
02825 ndim = H5Sget_simple_extent_ndims(dspace);
02826 H5Sget_simple_extent_dims(dspace, dims, NULL);
02827
02828
02829
02830 #ifdef ADFH_FORTRAN_INDEXING
02831 if (ndim > 1 && !swap_dimensions(hid)) {
02832 H5Sclose(dspace);
02833 H5Dclose(did);
02834 H5Gclose(hid);
02835 set_error(ADFH_ERR_NEED_TRANSPOSE, err);
02836 return;
02837 }
02838 #endif
02839 for (n = 0; n < ndim; n++) {
02840 if (s_start[n] < 1)
02841 set_error(START_OUT_OF_DEFINED_RANGE, err);
02842 #ifdef ADFH_FORTRAN_INDEXING
02843 else if ((hsize_t)s_end[n] > dims[ndim-1-n])
02844 #else
02845 else if ((hsize_t)s_end[n] > dims[n])
02846 #endif
02847 set_error(END_OUT_OF_DEFINED_RANGE, err);
02848 else if (s_start[n] > s_end[n])
02849 set_error(MINIMUM_GT_MAXIMUM, err);
02850 else if (s_stride[n] < 1 ||
02851 s_stride[n] > (s_end[n] - s_start[n] + 1))
02852 set_error(BAD_STRIDE_VALUE, err);
02853 else
02854 set_error(NO_ERROR, err);
02855 if (*err != NO_ERROR) {
02856 H5Sclose(dspace);
02857 H5Dclose(did);
02858 H5Gclose(hid);
02859 return;
02860 }
02861 #ifdef ADFH_FORTRAN_INDEXING
02862 start[ndim-1-n] = s_start[n] - 1;
02863 stride[ndim-1-n] = s_stride[n];
02864 count[ndim-1-n] = (s_end[n] - s_start[n] + 1) / s_stride[n];
02865 #else
02866 start[n] = s_start[n] - 1;
02867 stride[n] = s_stride[n];
02868 count[n] = (s_end[n] - s_start[n] + 1) / s_stride[n];
02869 #endif
02870 }
02871
02872 H5Sselect_hyperslab(dspace, H5S_SELECT_SET, start, stride, count, NULL);
02873
02874
02875
02876 for (n = 0; n < m_num_dims; n++) {
02877 if (m_start[n] < 1)
02878 set_error(START_OUT_OF_DEFINED_RANGE, err);
02879 else if (m_end[n] > m_dims[n])
02880 set_error(END_OUT_OF_DEFINED_RANGE, err);
02881 else if (m_start[n] > m_end[n])
02882 set_error(MINIMUM_GT_MAXIMUM, err);
02883 else if (m_stride[n] < 1 ||
02884 m_stride[n] > (m_end[n] - m_start[n] + 1))
02885 set_error(BAD_STRIDE_VALUE, err);
02886 else
02887 set_error(NO_ERROR, err);
02888 if (*err != NO_ERROR) {
02889 H5Sclose(dspace);
02890 H5Dclose(did);
02891 H5Gclose(hid);
02892 return;
02893 }
02894 #ifdef ADFH_FORTRAN_INDEXING
02895 dims[m_num_dims-1-n] = m_dims[n];
02896 start[m_num_dims-1-n] = m_start[n] - 1;
02897 stride[m_num_dims-1-n] = m_stride[n];
02898 count[m_num_dims-1-n] = (m_end[n] - m_start[n] + 1) / m_stride[n];
02899 #else
02900 dims[n] = m_dims[n];
02901 start[n] = m_start[n] - 1;
02902 stride[n] = m_stride[n];
02903 count[n] = (m_end[n] - m_start[n] + 1) / m_stride[n];
02904 #endif
02905 }
02906
02907 mspace = H5Screate_simple(m_num_dims, dims, NULL);
02908 ADFH_CHECK_HID(mspace);
02909
02910 H5Sselect_hyperslab(mspace, H5S_SELECT_SET, start, stride, count, NULL);
02911
02912 if (H5Sget_select_npoints(mspace) != H5Sget_select_npoints(dspace)) {
02913 H5Sclose(mspace);
02914 H5Sclose(dspace);
02915 H5Dclose(did);
02916 H5Gclose(hid);
02917 set_error(UNEQUAL_MEMORY_AND_DISK_DIMS, err);
02918 return;
02919 }
02920
02921
02922
02923 tid = H5Dget_type(did);
02924 ADFH_CHECK_HID(tid);
02925 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
02926 ADFH_CHECK_HID(mid);
02927 status = H5Dread(did, mid, mspace, dspace, H5P_DEFAULT, data);
02928
02929 H5Sclose(mspace);
02930 H5Sclose(dspace);
02931 H5Tclose(mid);
02932 H5Tclose(tid);
02933 H5Dclose(did);
02934 H5Gclose(hid);
02935
02936 if (status < 0)
02937 set_error(ADFH_ERR_DREAD, err);
02938 else
02939 set_error(NO_ERROR, err);
02940 }
02941
02942
02943
02944 void ADFH_Read_All_Data(const double id,
02945 char *data,
02946 int *err)
02947 {
02948 hid_t hid, did, tid, mid;
02949 herr_t status;
02950
02951 ADFH_DEBUG(("ADFH_Read_All_Data"));
02952
02953 if ((hid = open_node(id, err)) < 0) return;
02954
02955 if (has_data(hid)) {
02956 did = H5Dopen2(hid, D_DATA, H5P_DEFAULT);
02957 ADFH_CHECK_HID(did);
02958 tid = H5Dget_type(did);
02959 ADFH_CHECK_HID(tid);
02960 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
02961 ADFH_CHECK_HID(mid);
02962
02963 if (H5Dread(did, mid, H5S_ALL, H5S_ALL, H5P_DEFAULT, data) < 0)
02964 set_error(ADFH_ERR_DREAD, err);
02965 else
02966 set_error(NO_ERROR, err);
02967
02968 H5Tclose(mid);
02969 H5Tclose(tid);
02970 H5Dclose(did);
02971 }
02972 else
02973 set_error(NO_DATA, err);
02974 H5Gclose(hid);
02975 }
02976
02977
02978
02979 void ADFH_Write_Block_Data(const double ID,
02980 const long b_start,
02981 const long b_end,
02982 char *data,
02983 int *err )
02984 {
02985 hid_t hid, did, mid, tid, dspace;
02986 size_t size, count, offset;
02987 char *buff;
02988
02989 ADFH_DEBUG(("ADFH_Write_Block_Data"));
02990
02991 if (data == NULL) {
02992 set_error(NULL_POINTER, err);
02993 return;
02994 }
02995 if (b_start > b_end) {
02996 set_error(MINIMUM_GT_MAXIMUM, err);
02997 return;
02998 }
02999 if (b_start < 1) {
03000 set_error(START_OUT_OF_DEFINED_RANGE, err);
03001 return;
03002 }
03003 hid = to_HDF_ID(ID);
03004 if (is_link(hid)) {
03005 set_error(ADFH_ERR_LINK_DATA, err);
03006 return;
03007 }
03008 if (!has_data(hid)) {
03009 set_error(NO_DATA, err);
03010 return;
03011 }
03012 if ((did = H5Dopen2(hid, D_DATA, H5P_DEFAULT)) < 0) {
03013 set_error(ADFH_ERR_DOPEN, err);
03014 return;
03015 }
03016
03017 dspace = H5Dget_space(did);
03018 ADFH_CHECK_HID(dspace);
03019 count = (size_t)H5Sget_simple_extent_npoints(dspace);
03020 H5Sclose(dspace);
03021
03022 if ((size_t)b_end > count) {
03023 H5Dclose(did);
03024 set_error(END_OUT_OF_DEFINED_RANGE, err);
03025 return;
03026 }
03027
03028
03029
03030
03031
03032 ADFH_CHECK_HID(did);
03033 tid = H5Dget_type(did);
03034 ADFH_CHECK_HID(tid);
03035 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
03036 ADFH_CHECK_HID(mid);
03037 size = H5Tget_size(mid);
03038
03039 if ((buff = (char *) malloc (size * count)) == NULL) {
03040 H5Tclose(mid);
03041 H5Tclose(tid);
03042 H5Dclose(did);
03043 set_error(MEMORY_ALLOCATION_FAILED, err);
03044 return;
03045 }
03046
03047 if (H5Dread(did, mid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buff) < 0)
03048 set_error(ADFH_ERR_DREAD, err);
03049 else {
03050 offset = size * (b_start - 1);
03051 count = size * (b_end - b_start + 1);
03052 memcpy(&buff[offset], data, count);
03053 if (H5Dwrite(did, mid, H5S_ALL, H5S_ALL, H5P_DEFAULT, buff) < 0)
03054 set_error(ADFH_ERR_DWRITE, err);
03055 else
03056 set_error(NO_ERROR, err);
03057 }
03058
03059 free (buff);
03060 H5Tclose(mid);
03061 H5Tclose(tid);
03062 H5Dclose(did);
03063 }
03064
03065
03066
03067 void ADFH_Write_Data(const double ID,
03068 const int s_start[],
03069 const int s_end[],
03070 const int s_stride[],
03071 const int m_num_dims,
03072 const int m_dims[],
03073 const int m_start[],
03074 const int m_end[],
03075 const int m_stride[],
03076 const char *data,
03077 int *err )
03078 {
03079 int n, ndim;
03080 hid_t hid, did, mid, tid, dspace, mspace;
03081 hsize_t dims[ADF_MAX_DIMENSIONS];
03082 hsize_t start[ADF_MAX_DIMENSIONS];
03083 hsize_t stride[ADF_MAX_DIMENSIONS];
03084 hsize_t count[ADF_MAX_DIMENSIONS];
03085 herr_t status;
03086
03087 ADFH_DEBUG(("ADFH_Write_Data"));
03088
03089 if (data == NULL) {
03090 set_error(NULL_POINTER, err);
03091 return;
03092 }
03093 hid = to_HDF_ID(ID);
03094 if (is_link(hid)) {
03095 set_error(ADFH_ERR_LINK_DATA, err);
03096 return;
03097 }
03098 if (!has_data(hid)) {
03099 set_error(NO_DATA, err);
03100 return;
03101 }
03102 if ((did = H5Dopen2(hid, D_DATA, H5P_DEFAULT)) < 0) {
03103 set_error(ADFH_ERR_DOPEN, err);
03104 return;
03105 }
03106
03107
03108
03109 dspace = H5Dget_space(did);
03110 ADFH_CHECK_HID(dspace);
03111 ndim = H5Sget_simple_extent_ndims(dspace);
03112 H5Sget_simple_extent_dims(dspace, dims, NULL);
03113
03114
03115
03116 #ifdef ADFH_FORTRAN_INDEXING
03117 if (ndim > 1 && !swap_dimensions(hid)) {
03118 H5Sclose(dspace);
03119 H5Dclose(did);
03120 set_error(ADFH_ERR_NEED_TRANSPOSE, err);
03121 return;
03122 }
03123 #endif
03124 for (n = 0; n < ndim; n++) {
03125 if (s_start[n] < 1)
03126 set_error(START_OUT_OF_DEFINED_RANGE, err);
03127 #ifdef ADFH_FORTRAN_INDEXING
03128 else if ((hsize_t)s_end[n] > dims[ndim-1-n])
03129 #else
03130 else if ((hsize_t)s_end[n] > dims[n])
03131 #endif
03132 set_error(END_OUT_OF_DEFINED_RANGE, err);
03133 else if (s_start[n] > s_end[n])
03134 set_error(MINIMUM_GT_MAXIMUM, err);
03135 else if (s_stride[n] < 1 ||
03136 s_stride[n] > (s_end[n] - s_start[n] + 1))
03137 set_error(BAD_STRIDE_VALUE, err);
03138 else
03139 set_error(NO_ERROR, err);
03140 if (*err != NO_ERROR) {
03141 H5Sclose(dspace);
03142 H5Dclose(did);
03143 return;
03144 }
03145 #ifdef ADFH_FORTRAN_INDEXING
03146 start[ndim-1-n] = s_start[n] - 1;
03147 stride[ndim-1-n] = s_stride[n];
03148 count[ndim-1-n] = (s_end[n] - s_start[n] + 1) / s_stride[n];
03149 #else
03150 start[n] = s_start[n] - 1;
03151 stride[n] = s_stride[n];
03152 count[n] = (s_end[n] - s_start[n] + 1) / s_stride[n];
03153 #endif
03154 }
03155
03156 H5Sselect_hyperslab(dspace, H5S_SELECT_SET, start, stride, count, NULL);
03157
03158
03159
03160 for (n = 0; n < m_num_dims; n++) {
03161 if (m_start[n] < 1)
03162 set_error(START_OUT_OF_DEFINED_RANGE, err);
03163 else if (m_end[n] > m_dims[n])
03164 set_error(END_OUT_OF_DEFINED_RANGE, err);
03165 else if (m_start[n] > m_end[n])
03166 set_error(MINIMUM_GT_MAXIMUM, err);
03167 else if (m_stride[n] < 1 ||
03168 m_stride[n] > (m_end[n] - m_start[n] + 1))
03169 set_error(BAD_STRIDE_VALUE, err);
03170 else
03171 set_error(NO_ERROR, err);
03172 if (*err != NO_ERROR) {
03173 H5Sclose(dspace);
03174 H5Dclose(did);
03175 return;
03176 }
03177 #ifdef ADFH_FORTRAN_INDEXING
03178 dims[m_num_dims-1-n] = m_dims[n];
03179 start[m_num_dims-1-n] = m_start[n] - 1;
03180 stride[m_num_dims-1-n] = m_stride[n];
03181 count[m_num_dims-1-n] = (m_end[n] - m_start[n] + 1) / m_stride[n];
03182 #else
03183 dims[n] = m_dims[n];
03184 start[n] = m_start[n] - 1;
03185 stride[n] = m_stride[n];
03186 count[n] = (m_end[n] - m_start[n] + 1) / m_stride[n];
03187 #endif
03188 }
03189
03190 mspace = H5Screate_simple(m_num_dims, dims, NULL);
03191 ADFH_CHECK_HID(mspace);
03192
03193 H5Sselect_hyperslab(mspace, H5S_SELECT_SET, start, stride, count, NULL);
03194
03195 if (H5Sget_select_npoints(mspace) != H5Sget_select_npoints(dspace)) {
03196 H5Sclose(mspace);
03197 H5Sclose(dspace);
03198 H5Dclose(did);
03199 set_error(UNEQUAL_MEMORY_AND_DISK_DIMS, err);
03200 return;
03201 }
03202
03203
03204
03205 ADFH_CHECK_HID(did);
03206 tid = H5Dget_type(did);
03207 ADFH_CHECK_HID(tid);
03208 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
03209 ADFH_CHECK_HID(mid);
03210 status = H5Dwrite(did, mid, mspace, dspace, H5P_DEFAULT, data);
03211
03212 H5Sclose(mspace);
03213 H5Sclose(dspace);
03214 H5Tclose(mid);
03215 H5Tclose(tid);
03216 H5Dclose(did);
03217
03218 if (status < 0)
03219 set_error(ADFH_ERR_DWRITE, err);
03220 else
03221 set_error(NO_ERROR, err);
03222 }
03223
03224
03225
03226 void ADFH_Write_All_Data(const double id,
03227 const char *data,
03228 int *err)
03229 {
03230 hid_t hid = to_HDF_ID(id);
03231 hid_t did, tid, mid;
03232
03233 ADFH_DEBUG(("ADFH_Write_All_Data"));
03234
03235 if (data == NULL) {
03236 set_error(NULL_POINTER, err);
03237 return;
03238 }
03239 if (is_link(hid)) {
03240 set_error(ADFH_ERR_LINK_DATA, err);
03241 return;
03242 }
03243 if (has_data(hid)) {
03244 ADFH_CHECK_HID(hid);
03245 did = H5Dopen2(hid, D_DATA, H5P_DEFAULT);
03246 ADFH_CHECK_HID(did);
03247 tid = H5Dget_type(did);
03248 ADFH_CHECK_HID(tid);
03249 mid = H5Tget_native_type(tid, H5T_DIR_ASCEND);
03250 ADFH_CHECK_HID(mid);
03251
03252 if (H5Dwrite(did, mid, H5S_ALL, H5S_ALL, H5P_DEFAULT, data) < 0)
03253 set_error(ADFH_ERR_DWRITE, err);
03254 else
03255 set_error(NO_ERROR, err);
03256
03257 H5Tclose(mid);
03258 H5Tclose(tid);
03259 H5Dclose(did);
03260 }
03261 else
03262 set_error(NO_DATA, err);
03263 }
03264