00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include <stdio.h>
00022 #include <stdlib.h>
00023 #include <string.h>
00024 #include <ctype.h>
00025 #include <sys/types.h>
00026 #include <sys/stat.h>
00027 #if defined(_WIN32) && !defined(__NUTC__)
00028 #include <io.h>
00029 #else
00030 #include <unistd.h>
00031 #endif
00032 #include <errno.h>
00033
00034 #include "cgns_io.h"
00035 #include "adf/ADF.h"
00036 #ifdef BUILD_HDF5
00037 #include "adfh/ADFH.h"
00038 #endif
00039 #ifdef BUILD_XML
00040 #include "adfx/ADFX.h"
00041 #endif
00042 #ifdef MEM_DEBUG
00043 #include "cg_malloc.h"
00044 #endif
00045
00046 typedef struct {
00047 int type;
00048 int mode;
00049 double rootid;
00050 } cgns_io;
00051
00052 static int num_open = 0;
00053 static int num_iolist = 0;
00054 static cgns_io *iolist;
00055
00056 static char *cgio_ErrorMessage[] = {
00057 "no error",
00058 "invalid cgio index",
00059 "malloc/realloc failed",
00060 "unknown file open mode",
00061 "invalid file type",
00062 "filename is NULL or empty",
00063 "character string is too small",
00064 "file was not found",
00065 "pathname is NULL or empty",
00066 "no match for pathname",
00067 "error opening file for reading",
00068 "file opened in read-only mode",
00069 "NULL or empty string",
00070 "invalid configure option",
00071 "rename of tempfile file failed",
00072 "too many open files"
00073 };
00074 #define CGIO_MAX_ERRORS (sizeof(cgio_ErrorMessage)/sizeof(char *))
00075
00076 #define set_error(E) (last_err = E)
00077 #define get_error() last_err
00078
00079 static int last_err = CGIO_ERR_NONE;
00080 static int last_type = CGIO_FILE_NONE;
00081
00082 static int cgio_n_paths = 0;
00083 static char **cgio_paths = 0;
00084
00085
00086
00087
00088
00089 static cgns_io *get_cgnsio (int cgio_num, int write) {
00090 if (--cgio_num < 0 || cgio_num >= num_iolist) {
00091 last_err = CGIO_ERR_BAD_CGIO;
00092 return NULL;
00093 }
00094 if (write && iolist[cgio_num].mode == CGIO_MODE_READ) {
00095 last_err = CGIO_ERR_READ_ONLY;
00096 return NULL;
00097 }
00098 last_type = iolist[cgio_num].type;
00099 last_err = CGIO_ERR_NONE;
00100 return &iolist[cgio_num];
00101 }
00102
00103
00104
00105 static size_t compute_data_size (const char *data_type,
00106 int ndims, const int *dims)
00107 {
00108 int size;
00109 unsigned long count;
00110
00111 size = cgio_compute_data_size (data_type, ndims, dims, &count);
00112 return (size_t)size * (size_t)count;
00113 }
00114
00115
00116
00117 static int recurse_nodes (int input, double InputID,
00118 int output, double OutputID, int follow_links, int depth)
00119 {
00120 int n, nchild, cnt, name_len, file_len;
00121 char name[CGIO_MAX_NAME_LENGTH+1];
00122 char *link_name, *link_file;
00123 double childID, newID;
00124
00125
00126
00127 if (depth && cgio_copy_node(input, InputID, output, OutputID))
00128 return 1;
00129
00130
00131
00132 if (cgio_number_children(input, InputID, &nchild))
00133 return 1;
00134 for (n = 1; n <= nchild; n++) {
00135 if (cgio_children_ids(input, InputID, n, 1, &cnt, &childID) ||
00136 cgio_get_name(input, childID, name) ||
00137 cgio_is_link(input, childID, &name_len))
00138 return 1;
00139 if (name_len) {
00140 if (cgio_link_size(input, childID, &file_len, &name_len))
00141 return 1;
00142 }
00143 if (name_len && (file_len == 0 || follow_links == 0)) {
00144 link_file = (char *) malloc (file_len + name_len + 2);
00145 if (link_file == NULL) {
00146 set_error(CGIO_ERR_MALLOC);
00147 return 1;
00148 }
00149 link_name = link_file + file_len + 1;
00150 if (cgio_get_link(input, childID, link_file, link_name)) {
00151 free (link_name);
00152 return 1;
00153 }
00154 link_file[file_len] = 0;
00155 link_name[name_len] = 0;
00156 if (cgio_create_link(output, OutputID, name, link_file,
00157 link_name, &newID)) {
00158 free (link_file);
00159 return 1;
00160 }
00161 free (link_file);
00162 }
00163 else {
00164 if (cgio_create_node(output, OutputID, name, &newID) ||
00165 recurse_nodes(input, childID, output, newID,
00166 follow_links, ++depth))
00167 return 1;
00168 }
00169 }
00170 return 0;
00171 }
00172
00173
00174
00175 static int rewrite_file (int cginp, const char *filename)
00176 {
00177 int cgout, ierr;
00178 cgns_io *input, *output;
00179 char *tmpfile, *linkfile = NULL;
00180 #ifdef S_IFLNK
00181 struct stat st;
00182 #endif
00183
00184 input = get_cgnsio(cginp, 0);
00185 if (input->mode != CGIO_MODE_READ && cgio_flush_to_disk(cginp))
00186 return get_error();
00187
00188 #ifdef S_IFLNK
00189 if (!lstat(filename, &st) && (st.st_mode & S_IFLNK) == S_IFLNK) {
00190 int len;
00191 linkfile = (char *)malloc(st.st_size + 1);
00192 if (linkfile == NULL)
00193 return set_error(CGIO_ERR_MALLOC);
00194 len = readlink(filename, linkfile, st.st_size + 1);
00195 if (len < 0 || len > st.st_size) {
00196 free(linkfile);
00197 linkfile = NULL;
00198 }
00199 else {
00200 linkfile[len] = 0;
00201 }
00202 }
00203 #endif
00204 if (linkfile == NULL) {
00205 tmpfile = (char *)malloc(strlen(filename) + 6);
00206 if (tmpfile == NULL)
00207 return set_error(CGIO_ERR_MALLOC);
00208 sprintf(tmpfile, "%s.temp", filename);
00209 }
00210 else {
00211 tmpfile = (char *)malloc(strlen(linkfile) + 6);
00212 if (tmpfile == NULL) {
00213 free(linkfile);
00214 return set_error(CGIO_ERR_MALLOC);
00215 }
00216 sprintf(tmpfile, "%s.temp", linkfile);
00217 }
00218 unlink(tmpfile);
00219
00220 if (cgio_open_file(tmpfile, CGIO_MODE_WRITE, input->type, &cgout)) {
00221 unlink(tmpfile);
00222 free(tmpfile);
00223 if (linkfile != NULL) free(linkfile);
00224 return get_error();
00225 }
00226 output = get_cgnsio(cgout, 0);
00227
00228 ierr = recurse_nodes(cginp, input->rootid, cgout, output->rootid, 0, 0);
00229 cgio_close_file (cgout);
00230
00231 if (ierr) {
00232 unlink(tmpfile);
00233 free(tmpfile);
00234 if (linkfile != NULL) free(linkfile);
00235 return set_error(ierr);
00236 }
00237
00238 ierr = CGIO_ERR_NONE;
00239 cgio_close_file (cginp);
00240 if (linkfile == NULL) {
00241 unlink(filename);
00242 if (rename(tmpfile, filename))
00243 ierr = CGIO_ERR_FILE_RENAME;
00244 }
00245 else {
00246 unlink(linkfile);
00247 if (rename(tmpfile, linkfile))
00248 ierr = CGIO_ERR_FILE_RENAME;
00249 free(linkfile);
00250 }
00251 free(tmpfile);
00252 return set_error(ierr);
00253 }
00254
00255
00256
00257
00258
00259 int cgio_path_add (const char *path)
00260 {
00261 if (path == NULL || !*path)
00262 return set_error(CGIO_ERR_NULL_FILE);
00263 if (cgio_n_paths)
00264 cgio_paths = (char **) realloc (cgio_paths,
00265 (cgio_n_paths+1) * sizeof(char *));
00266 else
00267 cgio_paths = (char **) malloc (sizeof(char *));
00268 if (cgio_paths == NULL) {
00269 cgio_n_paths = 0;
00270 return set_error(CGIO_ERR_MALLOC);
00271 }
00272 cgio_paths[cgio_n_paths] = (char *) malloc (strlen(path)+1);
00273 if (cgio_paths[cgio_n_paths] == NULL)
00274 return set_error(CGIO_ERR_MALLOC);
00275 strcpy(cgio_paths[cgio_n_paths], path);
00276 cgio_n_paths++;
00277 return set_error(CGIO_ERR_NONE);
00278 }
00279
00280
00281
00282 int cgio_path_delete (const char *path)
00283 {
00284 int n;
00285
00286 if (cgio_n_paths == 0) {
00287 if (path != NULL)
00288 return set_error(CGIO_ERR_NO_MATCH);
00289 return set_error(CGIO_ERR_NONE);
00290 }
00291 if (path != NULL) {
00292 for (n = 0; n < cgio_n_paths; n++) {
00293 if (cgio_paths[n] != NULL &&
00294 0 == strcmp(path, cgio_paths[n])) {
00295 free(cgio_paths[n]);
00296 cgio_paths[n] = NULL;
00297 return set_error(CGIO_ERR_NONE);
00298 }
00299 }
00300 return set_error(CGIO_ERR_NO_MATCH);
00301 }
00302 for (n = 0; n < cgio_n_paths; n++) {
00303 if (cgio_paths[n] != NULL)
00304 free(cgio_paths[n]);
00305 }
00306 free(cgio_paths);
00307 cgio_n_paths = 0;
00308 cgio_paths = NULL;
00309 return set_error(CGIO_ERR_NONE);
00310 }
00311
00312
00313
00314 int cgio_find_file (const char *filename, int file_type,
00315 int max_path_len, char *pathname) {
00316 int n, size, len, type;
00317 char *p, *s;
00318
00319 if (filename == NULL || !*filename)
00320 return set_error(CGIO_ERR_NULL_FILE);
00321 size = max_path_len - 1 - strlen(filename);
00322 if (size < 0) return set_error(CGIO_ERR_TOO_SMALL);
00323 if (cgio_check_file(filename, &type) == CGIO_ERR_NONE &&
00324 (file_type == CGIO_FILE_NONE || file_type == type)) {
00325 strcpy(pathname, filename);
00326 return set_error(CGIO_ERR_NONE);
00327 }
00328 if (get_error() == CGIO_ERR_TOO_MANY)
00329 return CGIO_ERR_TOO_MANY;
00330
00331
00332
00333 if (*filename == '/'
00334 #ifdef _WIN32
00335 || *filename == '\\' || *(filename+1) == ':'
00336 #endif
00337 ) return set_error(CGIO_ERR_NOT_FOUND);
00338
00339 size -= 1;
00340
00341
00342
00343 if (file_type == CGIO_FILE_ADF)
00344 p = getenv ("ADF_LINK_PATH");
00345 #ifdef BUILD_HDF5
00346 else if (file_type == CGIO_FILE_HDF5)
00347 p = getenv ("HDF5_LINK_PATH");
00348 #endif
00349 #ifdef BUILD_XML
00350 else if (file_type == CGIO_FILE_XML)
00351 p = getenv ("XML_LINK_PATH");
00352 #endif
00353 else
00354 p = NULL;
00355 while (p != NULL && *p) {
00356 #ifdef _WIN32
00357 if (NULL == (s = strchr (p, ';')))
00358 #else
00359 if (NULL == (s = strchr (p, ':')))
00360 #endif
00361 len = strlen(p);
00362 else
00363 len = (int)(s++ - p);
00364 if (len) {
00365 if (len > size) return set_error(CGIO_ERR_TOO_SMALL);
00366 strncpy (pathname, p, len);
00367 #ifdef _WIN32
00368 for (n = 0; n < len; n++) {
00369 if (*p == '\\') *p = '/';
00370 }
00371 #endif
00372 p = pathname + len;
00373 if (*(p-1) != '/')
00374 *p++ = '/';
00375 strcpy (p, filename);
00376 if (cgio_check_file(pathname, &type) == CGIO_ERR_NONE &&
00377 (file_type == CGIO_FILE_NONE || file_type == type))
00378 return set_error(CGIO_ERR_NONE);
00379 }
00380 p = s;
00381 }
00382
00383
00384
00385 p = getenv ("CGNS_LINK_PATH");
00386 while (p != NULL && *p) {
00387 #ifdef _WIN32
00388 if (NULL == (s = strchr (p, ';')))
00389 #else
00390 if (NULL == (s = strchr (p, ':')))
00391 #endif
00392 len = strlen(p);
00393 else
00394 len = (int)(s++ - p);
00395 if (len) {
00396 if (len > size) return set_error(CGIO_ERR_TOO_SMALL);
00397 strncpy (pathname, p, len);
00398 #ifdef _WIN32
00399 for (n = 0; n < len; n++) {
00400 if (*p == '\\') *p = '/';
00401 }
00402 #endif
00403 p = pathname + len;
00404 if (*(p-1) != '/')
00405 *p++ = '/';
00406 strcpy (p, filename);
00407 if (cgio_check_file(pathname, &type) == CGIO_ERR_NONE &&
00408 (file_type == CGIO_FILE_NONE || file_type == type))
00409 return set_error(CGIO_ERR_NONE);
00410 }
00411 p = s;
00412 }
00413
00414
00415
00416 for (n = 0; n < cgio_n_paths; n++) {
00417 for (p = cgio_paths[n]; p != NULL && *p; ) {
00418 #ifdef _WIN32
00419 if (NULL == (s = strchr (p, ';')))
00420 #else
00421 if (NULL == (s = strchr (p, ':')))
00422 #endif
00423 len = strlen(p);
00424 else
00425 len = (int)(s++ - p);
00426 if (len) {
00427 if (len > size) return set_error(CGIO_ERR_TOO_SMALL);
00428 strncpy (pathname, p, len);
00429 #ifdef _WIN32
00430 for (n = 0; n < len; n++) {
00431 if (*p == '\\') *p = '/';
00432 }
00433 #endif
00434 p = pathname + len;
00435 if (*(p-1) != '/')
00436 *p++ = '/';
00437 strcpy (p, filename);
00438 if (cgio_check_file(pathname, &type) == CGIO_ERR_NONE &&
00439 (file_type == CGIO_FILE_NONE || file_type == type))
00440 return set_error(CGIO_ERR_NONE);
00441 }
00442 p = s;
00443 }
00444 }
00445
00446 return set_error(CGIO_ERR_NOT_FOUND);
00447 }
00448
00449
00450
00451
00452
00453 int cgio_is_supported (int file_type)
00454 {
00455 if (file_type == CGIO_FILE_ADF)
00456 return set_error(CGIO_ERR_NONE);
00457 #ifdef BUILD_HDF5
00458 if (file_type == CGIO_FILE_HDF5)
00459 return set_error(CGIO_ERR_NONE);
00460 #endif
00461 #ifdef BUILD_XML
00462 if (file_type == CGIO_FILE_XML)
00463 return set_error(CGIO_ERR_NONE);
00464 #endif
00465 return set_error(CGIO_ERR_FILE_TYPE);
00466 }
00467
00468
00469
00470 int cgio_configure (int what, void *value)
00471 {
00472 int ierr = CGIO_ERR_BAD_OPTION;
00473
00474 if (what > 300) {
00475 #ifdef BUILD_XML
00476 ierr = ADFX_Configure(what-300, value);
00477 #endif
00478 }
00479
00480
00481
00482
00483
00484
00485
00486
00487 return set_error(ierr);
00488 }
00489
00490
00491
00492 void cgio_cleanup ()
00493 {
00494 if (num_open) {
00495 int n;
00496 num_open++;
00497 for (n = 0; n < num_iolist; n++) {
00498 if (iolist[n].type != CGIO_FILE_NONE)
00499 cgio_close_file(n + 1);
00500 }
00501 free(iolist);
00502 num_iolist = 0;
00503 num_open = 0;
00504 }
00505 cgio_path_delete(NULL);
00506 }
00507
00508
00509
00510 int cgio_check_file (const char *filename, int *file_type)
00511 {
00512 int n;
00513 char *p, buf[256];
00514 FILE *fp;
00515 static char *HDF5sig = "\211HDF\r\n\032\n";
00516 struct stat st;
00517
00518 if (access (filename, 0) || stat (filename, &st) ||
00519 S_IFREG != (st.st_mode & S_IFREG))
00520 return set_error(CGIO_ERR_NOT_FOUND);
00521
00522 *file_type = CGIO_FILE_NONE;
00523 if (NULL == (fp = fopen (filename, "rb"))) {
00524 if (errno == EMFILE)
00525 return set_error(CGIO_ERR_TOO_MANY);
00526 return set_error(CGIO_ERR_FILE_OPEN);
00527 }
00528 fread (buf, 1, sizeof(buf), fp);
00529 buf[sizeof(buf)-1] = 0;
00530 fclose (fp);
00531
00532
00533
00534 if (0 == strncmp (&buf[4], "ADF Database Version", 20)) {
00535 *file_type = CGIO_FILE_ADF;
00536 return set_error(CGIO_ERR_NONE);
00537 }
00538
00539
00540
00541 for (n = 0; n < 8; n++) {
00542 if (buf[n] != HDF5sig[n]) break;
00543 }
00544 if (n == 8) {
00545 *file_type = CGIO_FILE_HDF5;
00546 return set_error(CGIO_ERR_NONE);
00547 }
00548
00549
00550
00551 for (n = 0; n < sizeof(buf)-1; n++) {
00552 if (!isascii (buf[n]))
00553 return set_error(CGIO_ERR_FILE_TYPE);
00554 }
00555 for (p = buf; *p && isspace(*p); p++)
00556 ;
00557 if (0 == strncmp (p, "<?xml", 5)) {
00558 while ((p = strchr (p, 'A')) != NULL) {
00559 if (0 == strncmp (p, "ADFXfile", 8)) {
00560 *file_type = CGIO_FILE_XML;
00561 return set_error(CGIO_ERR_NONE);
00562 }
00563 p++;
00564 }
00565 }
00566
00567 return set_error(CGIO_ERR_FILE_TYPE);
00568 }
00569
00570
00571
00572 int cgio_compute_data_size (const char *data_type,
00573 int ndims, const int *dims, unsigned long *count)
00574 {
00575 if (ndims > 0) {
00576 int i;
00577 *count = (unsigned long)dims[0];
00578 for (i = 1; i < ndims; i++)
00579 *count *= (unsigned long)dims[i];
00580 }
00581 else {
00582 *count = 0;
00583 }
00584 switch (*data_type) {
00585 case 'B':
00586 case 'C':
00587 return 1;
00588 case 'I':
00589 case 'U':
00590 if (data_type[1] == '4') return sizeof(int);
00591 if (data_type[1] == '8') return sizeof(long);
00592 break;
00593 case 'R':
00594 if (data_type[1] == '4') return sizeof(float);
00595 if (data_type[1] == '8') return sizeof(double);
00596 break;
00597 case 'X':
00598 if (data_type[1] == '4') return (2 * sizeof(float));
00599 if (data_type[1] == '8') return (2 * sizeof(double));
00600 break;
00601 }
00602 return 0;
00603 }
00604
00605
00606
00607
00608
00609 int cgio_open_file (const char *filename, int file_mode,
00610 int file_type, int *cgio_num)
00611 {
00612 int n, type, ierr;
00613 char *fmode;
00614 double rootid;
00615
00616 *cgio_num = 0;
00617 switch(file_mode) {
00618 case CGIO_MODE_READ:
00619 case 'r':
00620 case 'R':
00621 if (cgio_check_file(filename, &type))
00622 return get_error();
00623 file_type = type;
00624 file_mode = CGIO_MODE_READ;
00625 fmode = "READ_ONLY";
00626 break;
00627 case CGIO_MODE_WRITE:
00628 case 'w':
00629 case 'W':
00630 file_mode = CGIO_MODE_WRITE;
00631 fmode = "NEW";
00632 break;
00633 case CGIO_MODE_MODIFY:
00634 case 'm':
00635 case 'M':
00636 if (cgio_check_file(filename, &type))
00637 return get_error();
00638 file_type = type;
00639 file_mode = CGIO_MODE_MODIFY;
00640 fmode = "OLD";
00641 break;
00642 default:
00643 return set_error(CGIO_ERR_FILE_MODE);
00644 }
00645 last_type = file_type;
00646 if (file_type == CGIO_FILE_ADF) {
00647 ADF_Database_Open(filename, fmode, "NATIVE", &rootid, &ierr);
00648 if (ierr > 0) return set_error(ierr);
00649 }
00650 #ifdef BUILD_HDF5
00651 else if (file_type == CGIO_FILE_HDF5) {
00652 ADFH_Database_Open(filename, fmode, "NATIVE", &rootid, &ierr);
00653 if (ierr > 0) return set_error(ierr);
00654 }
00655 #endif
00656 #ifdef BUILD_XML
00657 else if (file_type == CGIO_FILE_XML) {
00658 ierr = ADFX_Open_File(filename, fmode, &rootid);
00659 if (ierr) return set_error(ierr);
00660 }
00661 #endif
00662 else {
00663 return set_error(CGIO_ERR_FILE_TYPE);
00664 }
00665
00666 if (num_iolist == 0) {
00667 num_iolist = 5;
00668 iolist = (cgns_io *) malloc (num_iolist * sizeof(cgns_io));
00669 if (iolist == NULL) {
00670 fprintf(stderr, "malloc failed for IO list\n");
00671 exit(1);
00672 }
00673 for (n = 0; n < num_iolist; n++)
00674 iolist[n].type = CGIO_FILE_NONE;
00675 }
00676 for (n = 0; n < num_iolist; n++) {
00677 if (iolist[n].type == CGIO_FILE_NONE)
00678 break;
00679 }
00680 if (n == num_iolist) {
00681 num_iolist++;
00682 iolist = (cgns_io *) realloc (iolist, num_iolist * sizeof(cgns_io));
00683 if (iolist == NULL) {
00684 fprintf(stderr, "realloc failed for IO list\n");
00685 exit(1);
00686 }
00687 }
00688 iolist[n].type = file_type;
00689 iolist[n].mode = file_mode;
00690 iolist[n].rootid = rootid;
00691 *cgio_num = n + 1;
00692 num_open++;
00693
00694 return set_error(CGIO_ERR_NONE);
00695 }
00696
00697
00698
00699 int cgio_close_file (int cgio_num)
00700 {
00701 int ierr;
00702 cgns_io *cgio;
00703
00704 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
00705 return get_error();
00706
00707 if (cgio->type == CGIO_FILE_ADF) {
00708 ADF_Database_Close(cgio->rootid, &ierr);
00709 if (ierr > 0) return set_error(ierr);
00710 }
00711 #ifdef BUILD_HDF5
00712 else if (cgio->type == CGIO_FILE_HDF5) {
00713 ADFH_Database_Close(cgio->rootid, &ierr);
00714 if (ierr > 0) return set_error(ierr);
00715 }
00716 #endif
00717 #ifdef BUILD_XML
00718 else if (cgio->type == CGIO_FILE_XML) {
00719 ierr = ADFX_Close_File(cgio->rootid, 0);
00720 if (ierr) return set_error(ierr);
00721 }
00722 #endif
00723 else {
00724 return set_error(CGIO_ERR_FILE_TYPE);
00725 }
00726
00727 cgio->type = CGIO_FILE_NONE;
00728 if (--num_open == 0) {
00729 free(iolist);
00730 num_iolist = 0;
00731 }
00732 return CGIO_ERR_NONE;
00733 }
00734
00735
00736
00737 int cgio_compress_file (int cgio_num, const char *filename)
00738 {
00739 int ierr;
00740 cgns_io *cgio;
00741
00742 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
00743 return get_error();
00744
00745 if (cgio->type == CGIO_FILE_ADF) {
00746 if (rewrite_file (cgio_num, filename)) {
00747 ierr = get_error();
00748 cgio_close_file(cgio_num);
00749 return set_error(ierr);
00750 }
00751 }
00752 #ifdef BUILD_HDF5
00753 else if (cgio->type == CGIO_FILE_HDF5) {
00754 if (rewrite_file (cgio_num, filename)) {
00755 ierr = get_error();
00756 cgio_close_file(cgio_num);
00757 return set_error(ierr);
00758 }
00759 }
00760 #endif
00761 #ifdef BUILD_XML
00762 else if (cgio->type == CGIO_FILE_XML) {
00763 ierr = ADFX_Close_File(cgio->rootid, 1);
00764 if (ierr) return set_error(ierr);
00765 cgio->type = CGIO_FILE_NONE;
00766 if (--num_open == 0) {
00767 free(iolist);
00768 num_iolist = 0;
00769 }
00770 }
00771 #endif
00772 else {
00773 return set_error(CGIO_ERR_FILE_TYPE);
00774 }
00775
00776 return CGIO_ERR_NONE;
00777 }
00778
00779
00780
00781 int cgio_copy_file (int cgio_num_inp, int cgio_num_out,
00782 int follow_links)
00783 {
00784 cgns_io *input, *output;
00785
00786 if ((input = get_cgnsio(cgio_num_inp, 0)) == NULL ||
00787 (output = get_cgnsio(cgio_num_out, 1)) == NULL)
00788 return get_error();
00789 if (input->mode != CGIO_MODE_READ &&
00790 cgio_flush_to_disk(cgio_num_inp))
00791 return get_error();
00792 if (recurse_nodes(cgio_num_inp, input->rootid,
00793 cgio_num_out, output->rootid, follow_links, 0))
00794 return get_error();
00795 return CGIO_ERR_NONE;
00796 }
00797
00798
00799
00800 int cgio_flush_to_disk (int cgio_num)
00801 {
00802 int ierr;
00803 cgns_io *cgio;
00804
00805 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
00806 return get_error();
00807 if (cgio->mode == CGIO_MODE_READ) return CGIO_ERR_NONE;
00808
00809 if (cgio->type == CGIO_FILE_ADF) {
00810 ADF_Flush_to_Disk(cgio->rootid, &ierr);
00811 if (ierr > 0) return set_error(ierr);
00812 }
00813 #ifdef BUILD_HDF5
00814 else if (cgio->type == CGIO_FILE_HDF5) {
00815 ADFH_Flush_to_Disk(cgio->rootid, &ierr);
00816 if (ierr > 0) return set_error(ierr);
00817 }
00818 #endif
00819 #ifdef BUILD_XML
00820 else if (cgio->type == CGIO_FILE_XML) {
00821 ierr = ADFX_Flush_to_Disk(cgio->rootid);
00822 if (ierr) return set_error(ierr);
00823 }
00824 #endif
00825 else {
00826 return set_error(CGIO_ERR_FILE_TYPE);
00827 }
00828
00829 return CGIO_ERR_NONE;
00830 }
00831
00832
00833
00834
00835
00836 int cgio_library_version (int cgio_num, char *version)
00837 {
00838 int ierr;
00839 cgns_io *cgio;
00840
00841 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
00842 return get_error();
00843
00844 if (cgio->type == CGIO_FILE_ADF) {
00845 ADF_Library_Version(version, &ierr);
00846 if (ierr > 0) return set_error(ierr);
00847 }
00848 #ifdef BUILD_HDF5
00849 else if (cgio->type == CGIO_FILE_HDF5) {
00850 ADFH_Library_Version(version, &ierr);
00851 if (ierr > 0) return set_error(ierr);
00852 }
00853 #endif
00854 #ifdef BUILD_XML
00855 else if (cgio->type == CGIO_FILE_XML) {
00856 ierr = ADFX_Library_Version(version);
00857 if (ierr) return set_error(ierr);
00858 }
00859 #endif
00860 else {
00861 return set_error(CGIO_ERR_FILE_TYPE);
00862 }
00863
00864 return CGIO_ERR_NONE;
00865 }
00866
00867
00868
00869 int cgio_file_version (int cgio_num, char *file_version,
00870 char *creation_date, char *modified_date)
00871 {
00872 int ierr;
00873 cgns_io *cgio;
00874
00875 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
00876 return get_error();
00877
00878 if (cgio->type == CGIO_FILE_ADF) {
00879 ADF_Database_Version(cgio->rootid, file_version,
00880 creation_date, modified_date, &ierr);
00881 if (ierr > 0) return set_error(ierr);
00882 }
00883 #ifdef BUILD_HDF5
00884 else if (cgio->type == CGIO_FILE_HDF5) {
00885 ADFH_Database_Version(cgio->rootid, file_version,
00886 creation_date, modified_date, &ierr);
00887 if (ierr > 0) return set_error(ierr);
00888 }
00889 #endif
00890 #ifdef BUILD_XML
00891 else if (cgio->type == CGIO_FILE_XML) {
00892 ierr = ADFX_File_Version(cgio->rootid, file_version,
00893 creation_date, modified_date);
00894 if (ierr) return set_error(ierr);
00895 }
00896 #endif
00897 else {
00898 return set_error(CGIO_ERR_FILE_TYPE);
00899 }
00900
00901 return CGIO_ERR_NONE;
00902 }
00903
00904
00905
00906 int cgio_get_root_id (int cgio_num, double *rootid)
00907 {
00908 cgns_io *cgio;
00909
00910 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
00911 return get_error();
00912 *rootid = cgio->rootid;
00913
00914 return CGIO_ERR_NONE;
00915 }
00916
00917
00918
00919 int cgio_get_file_type (int cgio_num, int *file_type)
00920 {
00921 cgns_io *cgio;
00922
00923 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
00924 return get_error();
00925 *file_type = cgio->type;
00926
00927 return CGIO_ERR_NONE;
00928 }
00929
00930
00931
00932
00933
00934 void cgio_error_code (int *errcode, int *file_type)
00935 {
00936 *errcode = last_err;
00937 *file_type = last_type;
00938 }
00939
00940
00941
00942 int cgio_error_message (int max_len, char *error_msg)
00943 {
00944 char msg[ADF_MAX_ERROR_STR_LENGTH+1];
00945
00946 if (last_err <= 0) {
00947 int errcode = -last_err;
00948 if (errcode >= CGIO_MAX_ERRORS)
00949 strcpy(msg, "unknown cgio error message");
00950 else
00951 strcpy(msg, cgio_ErrorMessage[errcode]);
00952 }
00953 else if (last_type == CGIO_FILE_ADF) {
00954 ADF_Error_Message(last_err, msg);
00955 }
00956 #ifdef BUILD_HDF5
00957 else if (last_type == CGIO_FILE_HDF5) {
00958 ADFH_Error_Message(last_err, msg);
00959 }
00960 #endif
00961 #ifdef BUILD_XML
00962 else if (last_type == CGIO_FILE_XML) {
00963 ADFX_Error_Message(last_err, msg);
00964 }
00965 #endif
00966 else {
00967 strcpy(msg, "unknown error message");
00968 }
00969 strncpy(error_msg, msg, max_len-1);
00970 error_msg[max_len-1] = 0;
00971 return last_err;
00972 }
00973
00974
00975
00976 void cgio_error_exit (const char *msg)
00977 {
00978 fflush(stdout);
00979 if (msg != NULL && *msg)
00980 fprintf(stderr, "%s:", msg);
00981 if (last_err) {
00982 char errmsg[81];
00983 cgio_error_message(sizeof(errmsg), errmsg);
00984 fprintf(stderr, "%s", errmsg);
00985 }
00986 putc('\n', stderr);
00987 cgio_cleanup();
00988 exit(1);
00989 }
00990
00991
00992
00993
00994
00995 int cgio_create_node (int cgio_num, double pid,
00996 const char *name, double *id)
00997 {
00998 int ierr;
00999 cgns_io *cgio;
01000
01001 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01002 return get_error();
01003
01004 if (cgio->type == CGIO_FILE_ADF) {
01005 ADF_Create(pid, name, id, &ierr);
01006 if (ierr > 0) return set_error(ierr);
01007 }
01008 #ifdef BUILD_HDF5
01009 else if (cgio->type == CGIO_FILE_HDF5) {
01010 ADFH_Create(pid, name, id, &ierr);
01011 if (ierr > 0) return set_error(ierr);
01012 }
01013 #endif
01014 #ifdef BUILD_XML
01015 else if (cgio->type == CGIO_FILE_XML) {
01016 ierr = ADFX_Create_Node(pid, name, id);
01017 if (ierr > 0) return set_error(ierr);
01018 }
01019 #endif
01020 else {
01021 return set_error(CGIO_ERR_FILE_TYPE);
01022 }
01023
01024 return CGIO_ERR_NONE;
01025 }
01026
01027
01028
01029 int cgio_new_node (int cgio_num, double pid, const char *name,
01030 const char *label, const char *data_type, int ndims,
01031 const int *dims, const void *data, double *id)
01032 {
01033 int ierr;
01034 cgns_io *cgio;
01035
01036 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01037 return get_error();
01038
01039 if (cgio->type == CGIO_FILE_ADF) {
01040 ADF_Create(pid, name, id, &ierr);
01041 if (ierr > 0) return set_error(ierr);
01042 ADF_Set_Label(*id, label, &ierr);
01043 if (ierr > 0) return set_error(ierr);
01044 if (data_type != NULL && strcmp(data_type, "MT")) {
01045 ADF_Put_Dimension_Information(*id, data_type, ndims, dims, &ierr);
01046 if (ierr > 0) return set_error(ierr);
01047 if (data != NULL) {
01048 ADF_Write_All_Data(*id, (const char *)data, &ierr);
01049 if (ierr > 0) return set_error(ierr);
01050 }
01051 }
01052 }
01053 #ifdef BUILD_HDF5
01054 else if (cgio->type == CGIO_FILE_HDF5) {
01055 ADFH_Create(pid, name, id, &ierr);
01056 if (ierr > 0) return set_error(ierr);
01057 ADFH_Set_Label(*id, label, &ierr);
01058 if (ierr > 0) return set_error(ierr);
01059 if (data_type != NULL && strcmp(data_type, "MT")) {
01060 ADFH_Put_Dimension_Information(*id, data_type, ndims, dims, &ierr);
01061 if (ierr > 0) return set_error(ierr);
01062 if (data != NULL) {
01063 ADFH_Write_All_Data(*id, (const char *)data, &ierr);
01064 if (ierr > 0) return set_error(ierr);
01065 }
01066 }
01067 }
01068 #endif
01069 #ifdef BUILD_XML
01070 else if (cgio->type == CGIO_FILE_XML) {
01071 ierr = ADFX_New_Node(pid, name, label, data_type,
01072 ndims, dims, data, id);
01073 if (ierr) return set_error(ierr);
01074 }
01075 #endif
01076 else {
01077 return set_error(CGIO_ERR_FILE_TYPE);
01078 }
01079
01080 return CGIO_ERR_NONE;
01081 }
01082
01083
01084
01085 int cgio_delete_node (int cgio_num, double pid, double id)
01086 {
01087 int ierr;
01088 cgns_io *cgio;
01089
01090 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01091 return get_error();
01092
01093 if (cgio->type == CGIO_FILE_ADF) {
01094 ADF_Delete(pid, id, &ierr);
01095 if (ierr > 0) return set_error(ierr);
01096 }
01097 #ifdef BUILD_HDF5
01098 else if (cgio->type == CGIO_FILE_HDF5) {
01099 ADFH_Delete(pid, id, &ierr);
01100 if (ierr > 0) return set_error(ierr);
01101 }
01102 #endif
01103 #ifdef BUILD_XML
01104 else if (cgio->type == CGIO_FILE_XML) {
01105 ierr = ADFX_Delete_Node(pid, id);
01106 if (ierr) return set_error(ierr);
01107 }
01108 #endif
01109 else {
01110 return set_error(CGIO_ERR_FILE_TYPE);
01111 }
01112
01113 return CGIO_ERR_NONE;
01114 }
01115
01116
01117
01118 int cgio_move_node (int cgio_num, double pid, double id,
01119 double new_pid)
01120 {
01121 int ierr;
01122 cgns_io *cgio;
01123
01124 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01125 return get_error();
01126
01127 if (cgio->type == CGIO_FILE_ADF) {
01128 ADF_Move_Child(pid, id, new_pid, &ierr);
01129 if (ierr > 0) return set_error(ierr);
01130 }
01131 #ifdef BUILD_HDF5
01132 else if (cgio->type == CGIO_FILE_HDF5) {
01133 ADFH_Move_Child(pid, id, new_pid, &ierr);
01134 if (ierr > 0) return set_error(ierr);
01135 }
01136 #endif
01137 #ifdef BUILD_XML
01138 else if (cgio->type == CGIO_FILE_XML) {
01139 ierr = ADFX_Move_Node(pid, id, new_pid);
01140 if (ierr) return set_error(ierr);
01141 }
01142 #endif
01143 else {
01144 return set_error(CGIO_ERR_FILE_TYPE);
01145 }
01146
01147 return CGIO_ERR_NONE;
01148 }
01149
01150
01151
01152 int cgio_copy_node (int cgio_num_inp, double id_inp,
01153 int cgio_num_out, double id_out)
01154 {
01155 cgns_io *input, *output;
01156 char label[CGIO_MAX_NAME_LENGTH+1];
01157 char data_type[CGIO_MAX_NAME_LENGTH+1];
01158 int ierr = 0, ndims, dims[CGIO_MAX_DIMENSIONS];
01159 size_t data_size = 0;
01160 void *data = NULL;
01161
01162 if ((input = get_cgnsio(cgio_num_inp, 0)) == NULL ||
01163 (output = get_cgnsio(cgio_num_out, 1)) == NULL)
01164 return get_error();
01165
01166
01167
01168 if (input->type == CGIO_FILE_ADF) {
01169 ADF_Get_Label(id_inp, label, &ierr);
01170 if (ierr > 0) return set_error(ierr);
01171 ADF_Get_Data_Type(id_inp, data_type, &ierr);
01172 if (ierr > 0) return set_error(ierr);
01173 ADF_Get_Number_of_Dimensions(id_inp, &ndims, &ierr);
01174 if (ierr > 0) return set_error(ierr);
01175 if (ndims > 0) {
01176 ADF_Get_Dimension_Values(id_inp, dims, &ierr);
01177 if (ierr > 0) return set_error(ierr);
01178 data_size = compute_data_size(data_type, ndims, dims);
01179 if (data_size) {
01180 data = malloc(data_size);
01181 if (data == NULL) return set_error(CGIO_ERR_MALLOC);
01182 ADF_Read_All_Data(id_inp, (char *)data, &ierr);
01183 if (ierr > 0) {
01184 free(data);
01185 return set_error(ierr);
01186 }
01187 }
01188 }
01189 }
01190 #ifdef BUILD_HDF5
01191 else if (input->type == CGIO_FILE_HDF5) {
01192 ADFH_Get_Label(id_inp, label, &ierr);
01193 if (ierr > 0) return set_error(ierr);
01194 ADFH_Get_Data_Type(id_inp, data_type, &ierr);
01195 if (ierr > 0) return set_error(ierr);
01196 ADFH_Get_Number_of_Dimensions(id_inp, &ndims, &ierr);
01197 if (ierr > 0) return set_error(ierr);
01198 if (ndims > 0) {
01199 ADFH_Get_Dimension_Values(id_inp, dims, &ierr);
01200 if (ierr > 0) return set_error(ierr);
01201 data_size = compute_data_size(data_type, ndims, dims);
01202 if (data_size) {
01203 data = malloc(data_size);
01204 if (data == NULL) return set_error(CGIO_ERR_MALLOC);
01205 ADFH_Read_All_Data(id_inp, (char *)data, &ierr);
01206 if (ierr > 0) {
01207 free(data);
01208 return set_error(ierr);
01209 }
01210 }
01211 }
01212 }
01213 #endif
01214 #ifdef BUILD_XML
01215 else if (input->type == CGIO_FILE_XML) {
01216 if ((ierr = ADFX_Get_Label(id_inp, label)) != 0 ||
01217 (ierr = ADFX_Get_Data_Type(id_inp, data_type)) != 0 ||
01218 (ierr = ADFX_Get_Dimensions (id_inp, &ndims, dims)) != 0)
01219 return set_error(ierr);
01220 if (ndims > 0) {
01221 data_size = compute_data_size(data_type, ndims, dims);
01222 if (data_size) {
01223 data = malloc(data_size);
01224 if (data == NULL) return set_error(CGIO_ERR_MALLOC);
01225 ierr = ADFX_Read_All_Data(id_inp, data);
01226 if (ierr > 0) {
01227 free(data);
01228 return set_error(ierr);
01229 }
01230 }
01231 }
01232 }
01233 #endif
01234 else {
01235 return set_error(CGIO_ERR_FILE_TYPE);
01236 }
01237
01238
01239
01240 if (output->type == CGIO_FILE_ADF) {
01241 ADF_Set_Label(id_out, label, &ierr);
01242 if (ierr <= 0) {
01243 ADF_Put_Dimension_Information(id_out, data_type, ndims,
01244 dims, &ierr);
01245 if (ierr <= 0 && data_size)
01246 ADF_Write_All_Data(id_out, (const char *)data, &ierr);
01247 }
01248 if (data_size) free(data);
01249 if (ierr > 0) return set_error(ierr);
01250 }
01251 #ifdef BUILD_HDF5
01252 else if (output->type == CGIO_FILE_HDF5) {
01253 ADFH_Set_Label(id_out, label, &ierr);
01254 if (ierr <= 0) {
01255 ADFH_Put_Dimension_Information(id_out, data_type, ndims,
01256 dims, &ierr);
01257 if (ierr <= 0 && data_size)
01258 ADFH_Write_All_Data(id_out, (const char *)data, &ierr);
01259 }
01260 if (data_size) free(data);
01261 if (ierr > 0) return set_error(ierr);
01262 }
01263 #endif
01264 #ifdef BUILD_XML
01265 else if (output->type == CGIO_FILE_XML) {
01266 ierr = ADFX_Set_Label(id_out, label);
01267 if (ierr == 0) {
01268 ierr = ADFX_Set_Dimensions(id_out, data_type, ndims, dims);
01269 if (ierr == 0 && data_size)
01270 ierr = ADFX_Write_All_Data(id_out, data);
01271 }
01272 if (data_size) free(data);
01273 if (ierr) return set_error(ierr);
01274 }
01275 #endif
01276 else {
01277 if (data_size) free(data);
01278 set_error(CGIO_ERR_FILE_TYPE);
01279 }
01280
01281 return CGIO_ERR_NONE;
01282 }
01283
01284
01285
01286 int cgio_release_id (int cgio_num, double id)
01287 {
01288 #ifdef BUILD_HDF5
01289 cgns_io *cgio;
01290
01291 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01292 return get_error();
01293 if (cgio->type == CGIO_FILE_HDF5) {
01294 ADFH_Release_ID(id);
01295 }
01296 #endif
01297
01298 return CGIO_ERR_NONE;
01299 }
01300
01301
01302
01303
01304
01305 int cgio_is_link (int cgio_num, double id, int *link_len)
01306 {
01307 int ierr;
01308 cgns_io *cgio;
01309
01310 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01311 return get_error();
01312
01313 if (cgio->type == CGIO_FILE_ADF) {
01314 ADF_Is_Link(id, link_len, &ierr);
01315 if (ierr > 0) return set_error(ierr);
01316 }
01317 #ifdef BUILD_HDF5
01318 else if (cgio->type == CGIO_FILE_HDF5) {
01319 ADFH_Is_Link(id, link_len, &ierr);
01320 if (ierr > 0) return set_error(ierr);
01321 }
01322 #endif
01323 #ifdef BUILD_XML
01324 else if (cgio->type == CGIO_FILE_XML) {
01325 ierr = ADFX_Is_Link(id, link_len);
01326 if (ierr) return set_error(ierr);
01327 }
01328 #endif
01329 else {
01330 return set_error(CGIO_ERR_FILE_TYPE);
01331 }
01332
01333 return CGIO_ERR_NONE;
01334 }
01335
01336
01337
01338 int cgio_link_size (int cgio_num, double id, int *file_len,
01339 int *name_len)
01340 {
01341 int ierr;
01342 cgns_io *cgio;
01343
01344 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01345 return get_error();
01346
01347 if (cgio->type == CGIO_FILE_ADF) {
01348 ADF_Link_Size(id, file_len, name_len, &ierr);
01349 if (ierr > 0) return set_error(ierr);
01350 }
01351 #ifdef BUILD_HDF5
01352 else if (cgio->type == CGIO_FILE_HDF5) {
01353 ADFH_Link_Size(id, file_len, name_len, &ierr);
01354 if (ierr > 0) return set_error(ierr);
01355 }
01356 #endif
01357 #ifdef BUILD_XML
01358 else if (cgio->type == CGIO_FILE_XML) {
01359 ierr = ADFX_Link_Size(id, file_len, name_len);
01360 if (ierr) return set_error(ierr);
01361 }
01362 #endif
01363 else {
01364 return set_error(CGIO_ERR_FILE_TYPE);
01365 }
01366
01367 return CGIO_ERR_NONE;
01368 }
01369
01370
01371
01372 int cgio_create_link (int cgio_num, double pid, const char *name,
01373 const char *filename, const char *name_in_file, double *id)
01374 {
01375 int ierr;
01376 cgns_io *cgio;
01377
01378 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01379 return get_error();
01380
01381 if (cgio->type == CGIO_FILE_ADF) {
01382 ADF_Link(pid, name, filename, name_in_file, id, &ierr);
01383 if (ierr > 0) return set_error(ierr);
01384 }
01385 #ifdef BUILD_HDF5
01386 else if (cgio->type == CGIO_FILE_HDF5) {
01387 ADFH_Link(pid, name, filename, name_in_file, id, &ierr);
01388 if (ierr > 0) return set_error(ierr);
01389 }
01390 #endif
01391 #ifdef BUILD_XML
01392 else if (cgio->type == CGIO_FILE_XML) {
01393 ierr = ADFX_Create_Link(pid, name, filename, name_in_file, id);
01394 if (ierr) return set_error(ierr);
01395 }
01396 #endif
01397 else {
01398 return set_error(CGIO_ERR_FILE_TYPE);
01399 }
01400
01401 return CGIO_ERR_NONE;
01402 }
01403
01404
01405
01406 int cgio_get_link (int cgio_num, double id,
01407 char *filename, char *name_in_file)
01408 {
01409 int ierr;
01410 cgns_io *cgio;
01411
01412 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01413 return get_error();
01414
01415 if (cgio->type == CGIO_FILE_ADF) {
01416 ADF_Get_Link_Path(id, filename, name_in_file, &ierr);
01417 if (ierr > 0) return set_error(ierr);
01418 }
01419 #ifdef BUILD_HDF5
01420 else if (cgio->type == CGIO_FILE_HDF5) {
01421 ADFH_Get_Link_Path(id, filename, name_in_file, &ierr);
01422 if (ierr > 0) return set_error(ierr);
01423 }
01424 #endif
01425 #ifdef BUILD_XML
01426 else if (cgio->type == CGIO_FILE_XML) {
01427 ierr = ADFX_Get_Link(id, filename, name_in_file);
01428 if (ierr) return set_error(ierr);
01429 }
01430 #endif
01431 else {
01432 return set_error(CGIO_ERR_FILE_TYPE);
01433 }
01434
01435 return CGIO_ERR_NONE;
01436 }
01437
01438
01439
01440
01441
01442 int cgio_number_children (int cgio_num, double id,
01443 int *num_children)
01444 {
01445 int ierr;
01446 cgns_io *cgio;
01447
01448 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01449 return get_error();
01450
01451 if (cgio->type == CGIO_FILE_ADF) {
01452 ADF_Number_of_Children(id, num_children, &ierr);
01453 if (ierr > 0) return set_error(ierr);
01454 }
01455 #ifdef BUILD_HDF5
01456 else if (cgio->type == CGIO_FILE_HDF5) {
01457 ADFH_Number_of_Children(id, num_children, &ierr);
01458 if (ierr > 0) return set_error(ierr);
01459 }
01460 #endif
01461 #ifdef BUILD_XML
01462 else if (cgio->type == CGIO_FILE_XML) {
01463 ierr = ADFX_Number_Children(id, num_children);
01464 if (ierr) return set_error(ierr);
01465 }
01466 #endif
01467 else {
01468 return set_error(CGIO_ERR_FILE_TYPE);
01469 }
01470
01471 return CGIO_ERR_NONE;
01472 }
01473
01474
01475
01476 int cgio_children_ids (int cgio_num, double pid,
01477 int start, int max_ret, int *num_ret, double *ids)
01478 {
01479 int ierr;
01480 cgns_io *cgio;
01481
01482 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01483 return get_error();
01484
01485 if (cgio->type == CGIO_FILE_ADF) {
01486 ADF_Children_IDs(pid, start, max_ret, num_ret, ids, &ierr);
01487 if (ierr > 0) return set_error(ierr);
01488 }
01489 #ifdef BUILD_HDF5
01490 else if (cgio->type == CGIO_FILE_HDF5) {
01491 ADFH_Children_IDs(pid, start, max_ret, num_ret, ids, &ierr);
01492 if (ierr > 0) return set_error(ierr);
01493 }
01494 #endif
01495 #ifdef BUILD_XML
01496 else if (cgio->type == CGIO_FILE_XML) {
01497 ierr = ADFX_Children_IDs(pid, start, max_ret, num_ret, ids);
01498 if (ierr) return set_error(ierr);
01499 }
01500 #endif
01501 else {
01502 return set_error(CGIO_ERR_FILE_TYPE);
01503 }
01504
01505 return CGIO_ERR_NONE;
01506 }
01507
01508
01509
01510 int cgio_children_names (int cgio_num, double pid, int start, int max_ret,
01511 int name_len, int *num_ret, char *names)
01512 {
01513 int ierr;
01514 cgns_io *cgio;
01515
01516 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01517 return get_error();
01518
01519 if (cgio->type == CGIO_FILE_ADF) {
01520 ADF_Children_Names(pid, start, max_ret, name_len-1,
01521 num_ret, names, &ierr);
01522 if (ierr > 0) return set_error(ierr);
01523 }
01524 #ifdef BUILD_HDF5
01525 else if (cgio->type == CGIO_FILE_HDF5) {
01526 ADFH_Children_Names(pid, start, max_ret, name_len,
01527 num_ret, names, &ierr);
01528 if (ierr > 0) return set_error(ierr);
01529 }
01530 #endif
01531 #ifdef BUILD_XML
01532 else if (cgio->type == CGIO_FILE_XML) {
01533 ierr = ADFX_Children_Names(pid, start, max_ret, name_len,
01534 num_ret, names);
01535 if (ierr) return set_error(ierr);
01536 }
01537 #endif
01538 else {
01539 return set_error(CGIO_ERR_FILE_TYPE);
01540 }
01541
01542 return CGIO_ERR_NONE;
01543 }
01544
01545
01546
01547
01548
01549 int cgio_get_node_id (int cgio_num, double pid,
01550 const char *name, double *id)
01551 {
01552 int ierr;
01553 cgns_io *cgio;
01554
01555 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01556 return get_error();
01557
01558 if (cgio->type == CGIO_FILE_ADF) {
01559 ADF_Get_Node_ID(pid, name, id, &ierr);
01560 if (ierr > 0) return set_error(ierr);
01561 }
01562 #ifdef BUILD_HDF5
01563 else if (cgio->type == CGIO_FILE_HDF5) {
01564 ADFH_Get_Node_ID(pid, name, id, &ierr);
01565 if (ierr > 0) return set_error(ierr);
01566 }
01567 #endif
01568 #ifdef BUILD_XML
01569 else if (cgio->type == CGIO_FILE_XML) {
01570 ierr = ADFX_Get_Node_ID(pid, name, id);
01571 if (ierr) return set_error(ierr);
01572 }
01573 #endif
01574 else {
01575 return set_error(CGIO_ERR_FILE_TYPE);
01576 }
01577
01578 return CGIO_ERR_NONE;
01579 }
01580
01581
01582
01583 int cgio_get_name (int cgio_num, double id, char *name)
01584 {
01585 int ierr;
01586 cgns_io *cgio;
01587
01588 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01589 return get_error();
01590
01591 if (cgio->type == CGIO_FILE_ADF) {
01592 ADF_Get_Name(id, name, &ierr);
01593 if (ierr > 0) return set_error(ierr);
01594 }
01595 #ifdef BUILD_HDF5
01596 else if (cgio->type == CGIO_FILE_HDF5) {
01597 ADFH_Get_Name(id, name, &ierr);
01598 if (ierr > 0) return set_error(ierr);
01599 }
01600 #endif
01601 #ifdef BUILD_XML
01602 else if (cgio->type == CGIO_FILE_XML) {
01603 ierr = ADFX_Get_Name(id, name);
01604 if (ierr) return set_error(ierr);
01605 }
01606 #endif
01607 else {
01608 return set_error(CGIO_ERR_FILE_TYPE);
01609 }
01610
01611 return CGIO_ERR_NONE;
01612 }
01613
01614
01615
01616 int cgio_get_label (int cgio_num, double id, char *label)
01617 {
01618 int ierr;
01619 cgns_io *cgio;
01620
01621 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01622 return get_error();
01623
01624 if (cgio->type == CGIO_FILE_ADF) {
01625 ADF_Get_Label(id, label, &ierr);
01626 if (ierr > 0) return set_error(ierr);
01627 }
01628 #ifdef BUILD_HDF5
01629 else if (cgio->type == CGIO_FILE_HDF5) {
01630 ADFH_Get_Label(id, label, &ierr);
01631 if (ierr > 0) return set_error(ierr);
01632 }
01633 #endif
01634 #ifdef BUILD_XML
01635 else if (cgio->type == CGIO_FILE_XML) {
01636 ierr = ADFX_Get_Label(id, label);
01637 if (ierr) return set_error(ierr);
01638 }
01639 #endif
01640 else {
01641 return set_error(CGIO_ERR_FILE_TYPE);
01642 }
01643
01644 return CGIO_ERR_NONE;
01645 }
01646
01647
01648
01649 int cgio_get_data_type (int cgio_num, double id, char *data_type)
01650 {
01651 int ierr;
01652 cgns_io *cgio;
01653
01654 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01655 return get_error();
01656
01657 if (cgio->type == CGIO_FILE_ADF) {
01658 ADF_Get_Data_Type(id, data_type, &ierr);
01659 if (ierr > 0) return set_error(ierr);
01660 }
01661 #ifdef BUILD_HDF5
01662 else if (cgio->type == CGIO_FILE_HDF5) {
01663 ADFH_Get_Data_Type(id, data_type, &ierr);
01664 if (ierr > 0) return set_error(ierr);
01665 }
01666 #endif
01667 #ifdef BUILD_XML
01668 else if (cgio->type == CGIO_FILE_XML) {
01669 ierr = ADFX_Get_Data_Type(id, data_type);
01670 if (ierr) return set_error(ierr);
01671 }
01672 #endif
01673 else {
01674 return set_error(CGIO_ERR_FILE_TYPE);
01675 }
01676
01677 return CGIO_ERR_NONE;
01678 }
01679
01680
01681
01682 int cgio_get_data_size (int cgio_num, double id, unsigned long *data_size)
01683 {
01684 int ierr, byte, ndims, dims[CGIO_MAX_DIMENSIONS];
01685 char data_type[CGIO_MAX_NAME_LENGTH];
01686 cgns_io *cgio;
01687
01688 *data_size = 0;
01689 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01690 return get_error();
01691
01692 if (cgio->type == CGIO_FILE_ADF) {
01693 ADF_Get_Data_Type(id, data_type, &ierr);
01694 if (ierr > 0) return set_error(ierr);
01695 ADF_Get_Number_of_Dimensions(id, &ndims, &ierr);
01696 if (ierr > 0) return set_error(ierr);
01697 if (ndims > 0) {
01698 ADF_Get_Dimension_Values(id, dims, &ierr);
01699 if (ierr > 0) return set_error(ierr);
01700 }
01701 }
01702 #ifdef BUILD_HDF5
01703 else if (cgio->type == CGIO_FILE_HDF5) {
01704 ADFH_Get_Data_Type(id, data_type, &ierr);
01705 if (ierr > 0) return set_error(ierr);
01706 ADFH_Get_Number_of_Dimensions(id, &ndims, &ierr);
01707 if (ierr > 0) return set_error(ierr);
01708 if (ndims > 0) {
01709 ADFH_Get_Dimension_Values(id, dims, &ierr);
01710 if (ierr > 0) return set_error(ierr);
01711 }
01712 }
01713 #endif
01714 #ifdef BUILD_XML
01715 else if (cgio->type == CGIO_FILE_XML) {
01716 ierr = ADFX_Get_Data_Type(id, data_type);
01717 if (ierr) return set_error(ierr);
01718 ierr = ADFX_Get_Dimensions(id, &ndims, dims);
01719 if (ierr) return set_error(ierr);
01720 }
01721 #endif
01722 else {
01723 return set_error(CGIO_ERR_FILE_TYPE);
01724 }
01725
01726 byte = cgio_compute_data_size(data_type, ndims, dims, data_size);
01727 *data_size *= (unsigned long)byte;
01728 return CGIO_ERR_NONE;
01729 }
01730
01731
01732
01733 int cgio_get_dimensions (int cgio_num, double id,
01734 int *num_dims, int *dims)
01735 {
01736 int ierr;
01737 cgns_io *cgio;
01738
01739 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01740 return get_error();
01741
01742 if (cgio->type == CGIO_FILE_ADF) {
01743 ADF_Get_Number_of_Dimensions(id, num_dims, &ierr);
01744 if (NULL != dims && ierr <= 0 && *num_dims > 0)
01745 ADF_Get_Dimension_Values(id, dims, &ierr);
01746 if (ierr > 0) return set_error(ierr);
01747 }
01748 #ifdef BUILD_HDF5
01749 else if (cgio->type == CGIO_FILE_HDF5) {
01750 ADFH_Get_Number_of_Dimensions(id, num_dims, &ierr);
01751 if (NULL != dims && ierr <= 0 && *num_dims > 0)
01752 ADFH_Get_Dimension_Values(id, dims, &ierr);
01753 if (ierr > 0) return set_error(ierr);
01754 }
01755 #endif
01756 #ifdef BUILD_XML
01757 else if (cgio->type == CGIO_FILE_XML) {
01758 ierr = ADFX_Get_Dimensions(id, num_dims, dims);
01759 if (ierr) return set_error(ierr);
01760 }
01761 #endif
01762 else {
01763 return set_error(CGIO_ERR_FILE_TYPE);
01764 }
01765
01766 return CGIO_ERR_NONE;
01767 }
01768
01769
01770
01771 int cgio_read_all_data (int cgio_num, double id, void *data)
01772 {
01773 int ierr;
01774 cgns_io *cgio;
01775
01776 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01777 return get_error();
01778
01779 if (cgio->type == CGIO_FILE_ADF) {
01780 ADF_Read_All_Data(id, (char *)data, &ierr);
01781 if (ierr > 0) return set_error(ierr);
01782 }
01783 #ifdef BUILD_HDF5
01784 else if (cgio->type == CGIO_FILE_HDF5) {
01785 ADFH_Read_All_Data(id, (char *)data, &ierr);
01786 if (ierr > 0) return set_error(ierr);
01787 }
01788 #endif
01789 #ifdef BUILD_XML
01790 else if (cgio->type == CGIO_FILE_XML) {
01791 ierr = ADFX_Read_All_Data(id, data);
01792 if (ierr) return set_error(ierr);
01793 }
01794 #endif
01795 else {
01796 return set_error(CGIO_ERR_FILE_TYPE);
01797 }
01798
01799 return CGIO_ERR_NONE;
01800 }
01801
01802
01803
01804 int cgio_read_data (int cgio_num, double id,
01805 const int *s_start, const int *s_end, const int *s_stride,
01806 int m_num_dims, const int *m_dims, const int *m_start,
01807 const int *m_end, const int *m_stride, void *data)
01808 {
01809 int ierr;
01810 cgns_io *cgio;
01811
01812 if ((cgio = get_cgnsio(cgio_num, 0)) == NULL)
01813 return get_error();
01814
01815 if (cgio->type == CGIO_FILE_ADF) {
01816 ADF_Read_Data(id, s_start, s_end, s_stride, m_num_dims,
01817 m_dims, m_start, m_end, m_stride, (char *)data, &ierr);
01818 if (ierr > 0) return set_error(ierr);
01819 }
01820 #ifdef BUILD_HDF5
01821 else if (cgio->type == CGIO_FILE_HDF5) {
01822 ADFH_Read_Data(id, s_start, s_end, s_stride, m_num_dims,
01823 m_dims, m_start, m_end, m_stride, (char *)data, &ierr);
01824 if (ierr > 0) return set_error(ierr);
01825 }
01826 #endif
01827 #ifdef BUILD_XML
01828 else if (cgio->type == CGIO_FILE_XML) {
01829 ierr = ADFX_Read_Data(id, s_start, s_end, s_stride, m_num_dims,
01830 m_dims, m_start, m_end, m_stride, data);
01831 if (ierr) return set_error(ierr);
01832 }
01833 #endif
01834 else {
01835 return set_error(CGIO_ERR_FILE_TYPE);
01836 }
01837
01838 return CGIO_ERR_NONE;
01839 }
01840
01841
01842
01843
01844
01845 int cgio_set_name (int cgio_num, double pid, double id,
01846 const char *name)
01847 {
01848 int ierr;
01849 cgns_io *cgio;
01850
01851 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01852 return get_error();
01853
01854 if (cgio->type == CGIO_FILE_ADF) {
01855 ADF_Put_Name(pid, id, name, &ierr);
01856 if (ierr > 0) return set_error(ierr);
01857 }
01858 #ifdef BUILD_HDF5
01859 else if (cgio->type == CGIO_FILE_HDF5) {
01860 ADFH_Put_Name(pid, id, name, &ierr);
01861 if (ierr > 0) return set_error(ierr);
01862 }
01863 #endif
01864 #ifdef BUILD_XML
01865 else if (cgio->type == CGIO_FILE_XML) {
01866 ierr = ADFX_Set_Name(pid, id, name);
01867 if (ierr) return set_error(ierr);
01868 }
01869 #endif
01870 else {
01871 return set_error(CGIO_ERR_FILE_TYPE);
01872 }
01873
01874 return CGIO_ERR_NONE;
01875 }
01876
01877
01878
01879 int cgio_set_label (int cgio_num, double id, const char *label)
01880 {
01881 int ierr;
01882 cgns_io *cgio;
01883
01884 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01885 return get_error();
01886
01887 if (cgio->type == CGIO_FILE_ADF) {
01888 ADF_Set_Label(id, label, &ierr);
01889 if (ierr > 0) return set_error(ierr);
01890 }
01891 #ifdef BUILD_HDF5
01892 else if (cgio->type == CGIO_FILE_HDF5) {
01893 ADFH_Set_Label(id, label, &ierr);
01894 if (ierr > 0) return set_error(ierr);
01895 }
01896 #endif
01897 #ifdef BUILD_XML
01898 else if (cgio->type == CGIO_FILE_XML) {
01899 ierr = ADFX_Set_Label(id, label);
01900 if (ierr) return set_error(ierr);
01901 }
01902 #endif
01903 else {
01904 return set_error(CGIO_ERR_FILE_TYPE);
01905 }
01906
01907 return CGIO_ERR_NONE;
01908 }
01909
01910
01911
01912 int cgio_set_dimensions (int cgio_num, double id,
01913 const char *data_type, int num_dims, const int *dims)
01914 {
01915 int ierr;
01916 cgns_io *cgio;
01917
01918 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01919 return get_error();
01920
01921 if (cgio->type == CGIO_FILE_ADF) {
01922 ADF_Put_Dimension_Information(id, data_type, num_dims, dims, &ierr);
01923 if (ierr > 0) return set_error(ierr);
01924 }
01925 #ifdef BUILD_HDF5
01926 else if (cgio->type == CGIO_FILE_HDF5) {
01927 ADFH_Put_Dimension_Information(id, data_type, num_dims, dims, &ierr);
01928 if (ierr > 0) return set_error(ierr);
01929 }
01930 #endif
01931 #ifdef BUILD_XML
01932 else if (cgio->type == CGIO_FILE_XML) {
01933 ierr = ADFX_Set_Dimensions(id, data_type, num_dims, dims);
01934 if (ierr) return set_error(ierr);
01935 }
01936 #endif
01937 else {
01938 return set_error(CGIO_ERR_FILE_TYPE);
01939 }
01940
01941 return CGIO_ERR_NONE;
01942 }
01943
01944
01945
01946 int cgio_write_all_data (int cgio_num, double id,
01947 const void *data)
01948 {
01949 int ierr;
01950 cgns_io *cgio;
01951
01952 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01953 return get_error();
01954
01955 if (cgio->type == CGIO_FILE_ADF) {
01956 ADF_Write_All_Data(id, (const char *)data, &ierr);
01957 if (ierr > 0) return set_error(ierr);
01958 }
01959 #ifdef BUILD_HDF5
01960 else if (cgio->type == CGIO_FILE_HDF5) {
01961 ADFH_Write_All_Data(id, (const char *)data, &ierr);
01962 if (ierr > 0) return set_error(ierr);
01963 }
01964 #endif
01965 #ifdef BUILD_XML
01966 else if (cgio->type == CGIO_FILE_XML) {
01967 ierr = ADFX_Write_All_Data(id, data);
01968 if (ierr) return set_error(ierr);
01969 }
01970 #endif
01971 else {
01972 return set_error(CGIO_ERR_FILE_TYPE);
01973 }
01974
01975 return CGIO_ERR_NONE;
01976 }
01977
01978
01979
01980 int cgio_write_data (int cgio_num, double id,
01981 const int *s_start, const int *s_end, const int *s_stride,
01982 int m_num_dims, const int *m_dims, const int *m_start,
01983 const int *m_end, const int *m_stride, const void *data)
01984 {
01985 int ierr;
01986 cgns_io *cgio;
01987
01988 if ((cgio = get_cgnsio(cgio_num, 1)) == NULL)
01989 return get_error();
01990
01991 if (cgio->type == CGIO_FILE_ADF) {
01992 ADF_Write_Data(id, s_start, s_end, s_stride, m_num_dims,
01993 m_dims, m_start, m_end, m_stride, (const char *)data, &ierr);
01994 if (ierr > 0) return set_error(ierr);
01995 }
01996 #ifdef BUILD_HDF5
01997 else if (cgio->type == CGIO_FILE_HDF5) {
01998 ADFH_Write_Data(id, s_start, s_end, s_stride, m_num_dims,
01999 m_dims, m_start, m_end, m_stride, (const char *)data, &ierr);
02000 if (ierr > 0) return set_error(ierr);
02001 }
02002 #endif
02003 #ifdef BUILD_XML
02004 else if (cgio->type == CGIO_FILE_XML) {
02005 ierr = ADFX_Write_Data(id, s_start, s_end, s_stride, m_num_dims,
02006 m_dims, m_start, m_end, m_stride, data);
02007 if (ierr) return set_error(ierr);
02008 }
02009 #endif
02010 else {
02011 return set_error(CGIO_ERR_FILE_TYPE);
02012 }
02013
02014 return CGIO_ERR_NONE;
02015 }
02016