netCDF
4.2.1.1
|
00001 00008 #include "ncdispatch.h" 00009 00013 static int 00014 NC_put_vara(int ncid, int varid, const size_t *start, 00015 const size_t *edges, const void *value, nc_type memtype) 00016 { 00017 NC* ncp; 00018 int stat = NC_check_id(ncid, &ncp); 00019 if(stat != NC_NOERR) return stat; 00020 if(edges == NULL) { 00021 size_t shape[NC_MAX_VAR_DIMS]; 00022 int ndims; 00023 stat = nc_inq_varndims(ncid, varid, &ndims); 00024 if(stat != NC_NOERR) return stat; 00025 stat = NC_getshape(ncid, varid, ndims, shape); 00026 if(stat != NC_NOERR) return stat; 00027 return ncp->dispatch->put_vara(ncid, varid, start, shape, value, memtype); 00028 } else 00029 return ncp->dispatch->put_vara(ncid, varid, start, edges, value, memtype); 00030 } 00031 00035 static int 00036 NC_put_var(int ncid, int varid, const void *value, nc_type memtype) 00037 { 00038 int ndims; 00039 size_t shape[NC_MAX_VAR_DIMS]; 00040 int stat = nc_inq_varndims(ncid,varid, &ndims); 00041 if(stat) return stat; 00042 stat = NC_getshape(ncid,varid, ndims, shape); 00043 if(stat) return stat; 00044 return NC_put_vara(ncid, varid, NC_coord_zero, shape, value, memtype); 00045 } 00046 00050 static int 00051 NC_put_var1(int ncid, int varid, const size_t *coord, const void* value, 00052 nc_type memtype) 00053 { 00054 return NC_put_vara(ncid, varid, coord, NC_coord_one, value, memtype); 00055 } 00056 00060 int 00061 NCDEFAULT_put_vars(int ncid, int varid, const size_t * start, 00062 const size_t * edges, const ptrdiff_t * stride, 00063 const void *value, nc_type memtype) 00064 { 00065 NC* ncp; 00066 int stat = NC_check_id(ncid, &ncp); 00067 00068 if(stat != NC_NOERR) return stat; 00069 return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,NULL,value,memtype); 00070 } 00071 00075 int 00076 NCDEFAULT_put_varm( 00077 int ncid, 00078 int varid, 00079 const size_t * start, 00080 const size_t * edges, 00081 const ptrdiff_t * stride, 00082 const ptrdiff_t * imapp, 00083 const void *value0, 00084 nc_type memtype) 00085 { 00086 int status = NC_NOERR; 00087 nc_type vartype = NC_NAT; 00088 int varndims = 0; 00089 int maxidim = 0; 00090 NC* ncp; 00091 size_t memtypelen; 00092 ptrdiff_t cvtmap[NC_MAX_VAR_DIMS]; 00093 const char* value = (char*)value0; 00094 00095 status = NC_check_id (ncid, &ncp); 00096 if(status != NC_NOERR) return status; 00097 00098 /* 00099 if(NC_indef(ncp)) return NC_EINDEFINE; 00100 if(NC_readonly (ncp)) return NC_EPERM; 00101 */ 00102 00103 /* mid body */ 00104 status = nc_inq_vartype(ncid, varid, &vartype); 00105 if(status != NC_NOERR) return status; 00106 /* Check that this is an atomic type */ 00107 if(vartype >= NC_MAX_ATOMIC_TYPE) 00108 return NC_EMAPTYPE; 00109 00110 status = nc_inq_varndims(ncid, varid, &varndims); 00111 if(status != NC_NOERR) return status; 00112 00113 if(memtype == NC_NAT) { 00114 if(imapp != NULL && varndims != 0) { 00115 /* 00116 * convert map units from bytes to units of sizeof(type) 00117 */ 00118 size_t ii; 00119 const ptrdiff_t szof = (ptrdiff_t) nctypelen(vartype); 00120 for(ii = 0; ii < varndims; ii++) { 00121 if(imapp[ii] % szof != 0) { 00122 /*free(cvtmap);*/ 00123 return NC_EINVAL; 00124 } 00125 cvtmap[ii] = imapp[ii] / szof; 00126 } 00127 imapp = cvtmap; 00128 } 00129 memtype = vartype; 00130 } 00131 00132 if(memtype == NC_CHAR && vartype != NC_CHAR) 00133 return NC_ECHAR; 00134 else if(memtype != NC_CHAR && vartype == NC_CHAR) 00135 return NC_ECHAR; 00136 00137 memtypelen = nctypelen(memtype); 00138 00139 maxidim = (int) varndims - 1; 00140 00141 if (maxidim < 0) 00142 { 00143 /* 00144 * The variable is a scalar; consequently, 00145 * there s only one thing to get and only one place to put it. 00146 * (Why was I called?) 00147 */ 00148 size_t edge1[1] = {1}; 00149 return NC_put_vara(ncid, varid, start, edge1, value, memtype); 00150 } 00151 00152 /* 00153 * else 00154 * The variable is an array. 00155 */ 00156 { 00157 int idim; 00158 size_t *mystart = NULL; 00159 size_t *myedges; 00160 size_t *iocount; /* count vector */ 00161 size_t *stop; /* stop indexes */ 00162 size_t *length; /* edge lengths in bytes */ 00163 ptrdiff_t *mystride; 00164 ptrdiff_t *mymap; 00165 size_t varshape[NC_MAX_VAR_DIMS]; 00166 int isrecvar; 00167 size_t numrecs; 00168 int stride1; /* is stride all ones? */ 00169 00170 /* 00171 * Verify stride argument. 00172 */ 00173 stride1 = 1; /* assume ok; */ 00174 if(stride != NULL) { 00175 for (idim = 0; idim <= maxidim; ++idim) { 00176 if ((stride[idim] == 0) 00177 /* cast needed for braindead systems with signed size_t */ 00178 || ((unsigned long) stride[idim] >= X_INT_MAX)) 00179 { 00180 return NC_ESTRIDE; 00181 } 00182 if(stride[idim] != 1) stride1 = 0; 00183 } 00184 } 00185 00186 /* If stride1 is true, and there is no imap, then call get_vara 00187 directly 00188 */ 00189 if(stride1 && imapp == NULL) { 00190 return NC_put_vara(ncid, varid, start, edges, value, memtype); 00191 } 00192 00193 /* Compute some dimension related values */ 00194 isrecvar = NC_is_recvar(ncid,varid,&numrecs); 00195 NC_getshape(ncid,varid,varndims,varshape); 00196 00197 /* assert(sizeof(ptrdiff_t) >= sizeof(size_t)); */ 00198 mystart = (size_t *)calloc(varndims * 7, sizeof(ptrdiff_t)); 00199 if(mystart == NULL) return NC_ENOMEM; 00200 myedges = mystart + varndims; 00201 iocount = myedges + varndims; 00202 stop = iocount + varndims; 00203 length = stop + varndims; 00204 mystride = (ptrdiff_t *)(length + varndims); 00205 mymap = mystride + varndims; 00206 00207 /* 00208 * Initialize I/O parameters. 00209 */ 00210 for (idim = maxidim; idim >= 0; --idim) 00211 { 00212 mystart[idim] = start != NULL 00213 ? start[idim] 00214 : 0; 00215 00216 if (edges != NULL && edges[idim] == 0) 00217 { 00218 status = NC_NOERR; /* read/write no data */ 00219 goto done; 00220 } 00221 00222 myedges[idim] = edges != NULL 00223 ? edges[idim] 00224 : idim == 0 && isrecvar 00225 ? numrecs - mystart[idim] 00226 : varshape[idim] - mystart[idim]; 00227 mystride[idim] = stride != NULL 00228 ? stride[idim] 00229 : 1; 00230 mymap[idim] = imapp != NULL 00231 ? imapp[idim] 00232 : idim == maxidim 00233 ? 1 00234 : mymap[idim + 1] * (ptrdiff_t) myedges[idim + 1]; 00235 00236 iocount[idim] = 1; 00237 length[idim] = mymap[idim] * myedges[idim]; 00238 stop[idim] = mystart[idim] + myedges[idim] * mystride[idim]; 00239 } 00240 00241 /* 00242 * Check start, edges 00243 */ 00244 for (idim = isrecvar; idim < maxidim; ++idim) 00245 { 00246 if (mystart[idim] > varshape[idim]) 00247 { 00248 status = NC_EINVALCOORDS; 00249 goto done; 00250 } 00251 if (mystart[idim] + myedges[idim] > varshape[idim]) 00252 { 00253 status = NC_EEDGE; 00254 goto done; 00255 } 00256 } 00257 00258 /* Lower body */ 00259 /* 00260 * As an optimization, adjust I/O parameters when the fastest 00261 * dimension has unity stride both externally and internally. 00262 * In this case, the user could have called a simpler routine 00263 * (i.e. ncvar$1() 00264 */ 00265 if (mystride[maxidim] == 1 00266 && mymap[maxidim] == 1) 00267 { 00268 iocount[maxidim] = myedges[maxidim]; 00269 mystride[maxidim] = (ptrdiff_t) myedges[maxidim]; 00270 mymap[maxidim] = (ptrdiff_t) length[maxidim]; 00271 } 00272 00273 /* 00274 * Perform I/O. Exit when done. 00275 */ 00276 for (;;) 00277 { 00278 /* TODO: */ 00279 int lstatus = NC_put_vara(ncid, varid, mystart, iocount, 00280 value, memtype); 00281 if (lstatus != NC_NOERR) { 00282 if(status == NC_NOERR || lstatus != NC_ERANGE) 00283 status = lstatus; 00284 } 00285 00286 /* 00287 * The following code permutes through the variable s 00288 * external start-index space and it s internal address 00289 * space. At the UPC, this algorithm is commonly 00290 * called "odometer code". 00291 */ 00292 idim = maxidim; 00293 carry: 00294 value += (mymap[idim] * memtypelen); 00295 mystart[idim] += mystride[idim]; 00296 if (mystart[idim] == stop[idim]) 00297 { 00298 mystart[idim] = start[idim]; 00299 value -= (length[idim] * memtypelen); 00300 if (--idim < 0) 00301 break; /* normal return */ 00302 goto carry; 00303 } 00304 } /* I/O loop */ 00305 done: 00306 free(mystart); 00307 } /* variable is array */ 00308 return status; 00309 } 00310 00314 static int 00315 NC_put_vars(int ncid, int varid, const size_t *start, 00316 const size_t *edges, const ptrdiff_t *stride, 00317 const void *value, nc_type memtype) 00318 { 00319 NC* ncp; 00320 int stat = NC_check_id(ncid, &ncp); 00321 00322 if(stat != NC_NOERR) return stat; 00323 #ifdef USE_NETCDF4 00324 if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT; 00325 #endif 00326 return ncp->dispatch->put_vars(ncid,varid,start,edges,stride,value,memtype); 00327 } 00328 00332 static int 00333 NC_put_varm(int ncid, int varid, const size_t *start, 00334 const size_t *edges, const ptrdiff_t *stride, const ptrdiff_t* map, 00335 const void *value, nc_type memtype) 00336 { 00337 NC* ncp; 00338 int stat = NC_check_id(ncid, &ncp); 00339 00340 if(stat != NC_NOERR) return stat; 00341 #ifdef USE_NETCDF4 00342 if(memtype >= NC_FIRSTUSERTYPEID) memtype = NC_NAT; 00343 #endif 00344 return ncp->dispatch->put_varm(ncid,varid,start,edges,stride,map,value,memtype); 00345 } 00346 /* All these functions are part of this named group... */ 00351 00392 int 00393 nc_put_vara(int ncid, int varid, const size_t *startp, 00394 const size_t *countp, const void *op) 00395 { 00396 NC* ncp; 00397 int stat = NC_check_id(ncid, &ncp); 00398 nc_type xtype; 00399 if(stat != NC_NOERR) return stat; 00400 stat = nc_inq_vartype(ncid, varid, &xtype); 00401 if(stat != NC_NOERR) return stat; 00402 return NC_put_vara(ncid, varid, startp, countp, op, xtype); 00403 } 00404 00405 int 00406 nc_put_vara_text(int ncid, int varid, const size_t *startp, 00407 const size_t *countp, const char *op) 00408 { 00409 return NC_put_vara(ncid, varid, startp, countp, 00410 (void*)op, NC_CHAR); 00411 } 00412 00413 int 00414 nc_put_vara_schar(int ncid, int varid, const size_t *startp, 00415 const size_t *countp, const signed char *op) 00416 { 00417 NC* ncp; 00418 int stat = NC_check_id(ncid, &ncp); 00419 if(stat != NC_NOERR) return stat; 00420 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00421 NC_BYTE); 00422 } 00423 00424 int 00425 nc_put_vara_uchar(int ncid, int varid, const size_t *startp, 00426 const size_t *countp, const unsigned char *op) 00427 { 00428 NC* ncp; 00429 int stat = NC_check_id(ncid, &ncp); 00430 if(stat != NC_NOERR) return stat; 00431 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00432 T_uchar); 00433 } 00434 00435 int 00436 nc_put_vara_short(int ncid, int varid, const size_t *startp, 00437 const size_t *countp, const short *op) 00438 { 00439 NC* ncp; 00440 int stat = NC_check_id(ncid, &ncp); 00441 if(stat != NC_NOERR) return stat; 00442 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00443 NC_SHORT); 00444 } 00445 00446 int 00447 nc_put_vara_int(int ncid, int varid, const size_t *startp, 00448 const size_t *countp, const int *op) 00449 { 00450 NC* ncp; 00451 int stat = NC_check_id(ncid, &ncp); 00452 if(stat != NC_NOERR) return stat; 00453 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00454 NC_INT); 00455 } 00456 00457 int 00458 nc_put_vara_long(int ncid, int varid, const size_t *startp, 00459 const size_t *countp, const long *op) 00460 { 00461 NC* ncp; 00462 int stat = NC_check_id(ncid, &ncp); 00463 if(stat != NC_NOERR) return stat; 00464 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00465 T_long); 00466 } 00467 00468 int 00469 nc_put_vara_float(int ncid, int varid, const size_t *startp, 00470 const size_t *countp, const float *op) 00471 { 00472 NC* ncp; 00473 int stat = NC_check_id(ncid, &ncp); 00474 if(stat != NC_NOERR) return stat; 00475 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00476 T_float); 00477 } 00478 00479 int 00480 nc_put_vara_double(int ncid, int varid, const size_t *startp, 00481 const size_t *countp, const double *op) 00482 { 00483 NC* ncp; 00484 int stat = NC_check_id(ncid, &ncp); 00485 if(stat != NC_NOERR) return stat; 00486 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00487 T_double); 00488 } 00489 00490 int 00491 nc_put_vara_ubyte(int ncid, int varid, const size_t *startp, 00492 const size_t *countp, const unsigned char *op) 00493 { 00494 NC* ncp; 00495 int stat = NC_check_id(ncid, &ncp); 00496 if(stat != NC_NOERR) return stat; 00497 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00498 T_ubyte); 00499 } 00500 00501 int 00502 nc_put_vara_ushort(int ncid, int varid, const size_t *startp, 00503 const size_t *countp, const unsigned short *op) 00504 { 00505 NC* ncp; 00506 int stat = NC_check_id(ncid, &ncp); 00507 if(stat != NC_NOERR) return stat; 00508 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00509 T_ushort); 00510 } 00511 00512 int 00513 nc_put_vara_uint(int ncid, int varid, const size_t *startp, 00514 const size_t *countp, const unsigned int *op) 00515 { 00516 NC* ncp; 00517 int stat = NC_check_id(ncid, &ncp); 00518 if(stat != NC_NOERR) return stat; 00519 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00520 T_uint); 00521 } 00522 00523 int 00524 nc_put_vara_longlong(int ncid, int varid, const size_t *startp, 00525 const size_t *countp, const long long *op) 00526 { 00527 NC* ncp; 00528 int stat = NC_check_id(ncid, &ncp); 00529 if(stat != NC_NOERR) return stat; 00530 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00531 T_longlong); 00532 } 00533 00534 int 00535 nc_put_vara_ulonglong(int ncid, int varid, const size_t *startp, 00536 const size_t *countp, const unsigned long long *op) 00537 { 00538 NC* ncp; 00539 int stat = NC_check_id(ncid, &ncp); 00540 if(stat != NC_NOERR) return stat; 00541 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00542 NC_UINT64); 00543 } 00544 00545 #ifdef USE_NETCDF4 00546 int 00547 nc_put_vara_string(int ncid, int varid, const size_t *startp, 00548 const size_t *countp, const char* *op) 00549 { 00550 NC* ncp; 00551 int stat = NC_check_id(ncid, &ncp); 00552 if(stat != NC_NOERR) return stat; 00553 return NC_put_vara(ncid, varid, startp, countp, (void *)op, 00554 NC_STRING); 00555 } 00556 00557 #endif /*USE_NETCDF4*/ 00558 00582 int 00583 nc_put_var1(int ncid, int varid, const size_t *indexp, const void *op) 00584 { 00585 return NC_put_var1(ncid, varid, indexp, op, NC_NAT); 00586 } 00587 00588 int 00589 nc_put_var1_text(int ncid, int varid, const size_t *indexp, const char *op) 00590 { 00591 NC* ncp; 00592 int stat = NC_check_id(ncid, &ncp); 00593 if(stat != NC_NOERR) return stat; 00594 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_CHAR); 00595 } 00596 00597 int 00598 nc_put_var1_schar(int ncid, int varid, const size_t *indexp, const signed char *op) 00599 { 00600 NC* ncp; 00601 int stat = NC_check_id(ncid, &ncp); 00602 if(stat != NC_NOERR) return stat; 00603 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_BYTE); 00604 } 00605 00606 int 00607 nc_put_var1_uchar(int ncid, int varid, const size_t *indexp, const unsigned char *op) 00608 { 00609 NC* ncp; 00610 int stat = NC_check_id(ncid, &ncp); 00611 if(stat != NC_NOERR) return stat; 00612 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE); 00613 } 00614 00615 int 00616 nc_put_var1_short(int ncid, int varid, const size_t *indexp, const short *op) 00617 { 00618 NC* ncp; 00619 int stat = NC_check_id(ncid, &ncp); 00620 if(stat != NC_NOERR) return stat; 00621 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_SHORT); 00622 } 00623 00624 int 00625 nc_put_var1_int(int ncid, int varid, const size_t *indexp, const int *op) 00626 { 00627 NC* ncp; 00628 int stat = NC_check_id(ncid, &ncp); 00629 if(stat != NC_NOERR) return stat; 00630 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT); 00631 } 00632 00633 int 00634 nc_put_var1_long(int ncid, int varid, const size_t *indexp, const long *op) 00635 { 00636 NC* ncp; 00637 int stat = NC_check_id(ncid, &ncp); 00638 if(stat != NC_NOERR) return stat; 00639 return NC_put_var1(ncid, varid, indexp, (void*)op, longtype); 00640 } 00641 00642 int 00643 nc_put_var1_float(int ncid, int varid, const size_t *indexp, const float *op) 00644 { 00645 NC* ncp; 00646 int stat = NC_check_id(ncid, &ncp); 00647 if(stat != NC_NOERR) return stat; 00648 return NC_put_var1(ncid, varid, indexp, (void*)op, NC_FLOAT); 00649 } 00650 00651 int 00652 nc_put_var1_double(int ncid, int varid, const size_t *indexp, const double *op) 00653 { 00654 NC* ncp; 00655 int stat = NC_check_id(ncid, &ncp); 00656 if(stat != NC_NOERR) return stat; 00657 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_DOUBLE); 00658 } 00659 00660 int 00661 nc_put_var1_ubyte(int ncid, int varid, const size_t *indexp, const unsigned char *op) 00662 { 00663 NC* ncp; 00664 int stat = NC_check_id(ncid, &ncp); 00665 if(stat != NC_NOERR) return stat; 00666 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UBYTE); 00667 } 00668 00669 int 00670 nc_put_var1_ushort(int ncid, int varid, const size_t *indexp, const unsigned short *op) 00671 { 00672 NC* ncp; 00673 int stat = NC_check_id(ncid, &ncp); 00674 if(stat != NC_NOERR) return stat; 00675 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_USHORT); 00676 } 00677 00678 int 00679 nc_put_var1_uint(int ncid, int varid, const size_t *indexp, const unsigned int *op) 00680 { 00681 NC* ncp; 00682 int stat = NC_check_id(ncid, &ncp); 00683 if(stat != NC_NOERR) return stat; 00684 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT); 00685 } 00686 00687 int 00688 nc_put_var1_longlong(int ncid, int varid, const size_t *indexp, const long long *op) 00689 { 00690 NC* ncp; 00691 int stat = NC_check_id(ncid, &ncp); 00692 if(stat != NC_NOERR) return stat; 00693 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_INT64); 00694 } 00695 00696 int 00697 nc_put_var1_ulonglong(int ncid, int varid, const size_t *indexp, const unsigned long long *op) 00698 { 00699 NC* ncp; 00700 int stat = NC_check_id(ncid, &ncp); 00701 if(stat != NC_NOERR) return stat; 00702 return NC_put_var1(ncid, varid, indexp, (void *)op, NC_UINT64); 00703 } 00704 00705 #ifdef USE_NETCDF4 00706 int 00707 nc_put_var1_string(int ncid, int varid, const size_t *indexp, const char* *op) 00708 { 00709 NC* ncp; 00710 int stat = NC_check_id(ncid, &ncp); 00711 if(stat != NC_NOERR) return stat; 00712 return NC_put_var1(ncid, varid, indexp, (void*)op, NC_STRING); 00713 } 00714 #endif /*USE_NETCDF4*/ 00715 00763 int 00764 nc_put_var(int ncid, int varid, const void *op) 00765 { 00766 return NC_put_var(ncid, varid, op, NC_NAT); 00767 } 00768 00769 int 00770 nc_put_var_text(int ncid, int varid, const char *op) 00771 { 00772 NC* ncp; 00773 int stat = NC_check_id(ncid, &ncp); 00774 if(stat != NC_NOERR) return stat; 00775 return NC_put_var(ncid,varid,(void*)op,NC_CHAR); 00776 } 00777 00778 int 00779 nc_put_var_schar(int ncid, int varid, const signed char *op) 00780 { 00781 NC* ncp; 00782 int stat = NC_check_id(ncid, &ncp); 00783 if(stat != NC_NOERR) return stat; 00784 return NC_put_var(ncid,varid,(void*)op,NC_BYTE); 00785 } 00786 00787 int 00788 nc_put_var_uchar(int ncid, int varid, const unsigned char *op) 00789 { 00790 NC* ncp; 00791 int stat = NC_check_id(ncid, &ncp); 00792 if(stat != NC_NOERR) return stat; 00793 return NC_put_var(ncid,varid,(void*)op,T_uchar); 00794 } 00795 00796 int 00797 nc_put_var_short(int ncid, int varid, const short *op) 00798 { 00799 NC* ncp; 00800 int stat = NC_check_id(ncid, &ncp); 00801 if(stat != NC_NOERR) return stat; 00802 return NC_put_var(ncid,varid,(void*)op,NC_SHORT); 00803 } 00804 00805 int 00806 nc_put_var_int(int ncid, int varid, const int *op) 00807 { 00808 NC* ncp; 00809 int stat = NC_check_id(ncid, &ncp); 00810 if(stat != NC_NOERR) return stat; 00811 return NC_put_var(ncid,varid,(void*)op,NC_INT); 00812 } 00813 00814 int 00815 nc_put_var_long(int ncid, int varid, const long *op) 00816 { 00817 NC* ncp; 00818 int stat = NC_check_id(ncid, &ncp); 00819 if(stat != NC_NOERR) return stat; 00820 return NC_put_var(ncid,varid,(void*)op,T_long); 00821 } 00822 00823 int 00824 nc_put_var_float(int ncid, int varid, const float *op) 00825 { 00826 NC* ncp; 00827 int stat = NC_check_id(ncid, &ncp); 00828 if(stat != NC_NOERR) return stat; 00829 return NC_put_var(ncid,varid,(void*)op,T_float); 00830 } 00831 00832 int 00833 nc_put_var_double(int ncid, int varid, const double *op) 00834 { 00835 NC* ncp; 00836 int stat = NC_check_id(ncid, &ncp); 00837 if(stat != NC_NOERR) return stat; 00838 return NC_put_var(ncid,varid,(void*)op,T_double); 00839 } 00840 00841 int 00842 nc_put_var_ubyte(int ncid, int varid, const unsigned char *op) 00843 { 00844 NC* ncp; 00845 int stat = NC_check_id(ncid, &ncp); 00846 if(stat != NC_NOERR) return stat; 00847 return NC_put_var(ncid,varid,(void*)op,T_ubyte); 00848 } 00849 00850 int 00851 nc_put_var_ushort(int ncid, int varid, const unsigned short *op) 00852 { 00853 NC* ncp; 00854 int stat = NC_check_id(ncid, &ncp); 00855 if(stat != NC_NOERR) return stat; 00856 return NC_put_var(ncid,varid,(void*)op,T_ushort); 00857 } 00858 00859 int 00860 nc_put_var_uint(int ncid, int varid, const unsigned int *op) 00861 { 00862 NC* ncp; 00863 int stat = NC_check_id(ncid, &ncp); 00864 if(stat != NC_NOERR) return stat; 00865 return NC_put_var(ncid,varid,(void*)op,T_uint); 00866 } 00867 00868 int 00869 nc_put_var_longlong(int ncid, int varid, const long long *op) 00870 { 00871 NC* ncp; 00872 int stat = NC_check_id(ncid, &ncp); 00873 if(stat != NC_NOERR) return stat; 00874 return NC_put_var(ncid,varid,(void*)op,T_longlong); 00875 } 00876 00877 int 00878 nc_put_var_ulonglong(int ncid, int varid, const unsigned long long *op) 00879 { 00880 NC* ncp; 00881 int stat = NC_check_id(ncid, &ncp); 00882 if(stat != NC_NOERR) return stat; 00883 return NC_put_var(ncid,varid,(void*)op,NC_UINT64); 00884 } 00885 00886 #ifdef USE_NETCDF4 00887 int 00888 nc_put_var_string(int ncid, int varid, const char* *op) 00889 { 00890 NC* ncp; 00891 int stat = NC_check_id(ncid, &ncp); 00892 if(stat != NC_NOERR) return stat; 00893 return NC_put_var(ncid,varid,(void*)op,NC_STRING); 00894 } 00895 #endif /*USE_NETCDF4*/ 00896 00928 int 00929 nc_put_vars (int ncid, int varid, const size_t *startp, 00930 const size_t *countp, const ptrdiff_t *stridep, 00931 const void *op) 00932 { 00933 NC *ncp; 00934 int stat = NC_NOERR; 00935 00936 if ((stat = NC_check_id(ncid, &ncp))) 00937 return stat; 00938 return ncp->dispatch->put_vars(ncid, varid, startp, countp, 00939 stridep, op, NC_NAT); 00940 } 00941 00942 int 00943 nc_put_vars_text(int ncid, int varid, const size_t *startp, 00944 const size_t *countp, const ptrdiff_t *stridep, 00945 const char *op) 00946 { 00947 NC *ncp; 00948 int stat = NC_check_id(ncid, &ncp); 00949 if(stat != NC_NOERR) return stat; 00950 return NC_put_vars(ncid, varid, startp, countp, 00951 stridep,(void*)op,NC_CHAR); 00952 } 00953 00954 int 00955 nc_put_vars_schar(int ncid, int varid, const size_t *startp, 00956 const size_t *countp, const ptrdiff_t *stridep, 00957 const signed char *op) 00958 { 00959 NC *ncp; 00960 int stat = NC_check_id(ncid, &ncp); 00961 if(stat != NC_NOERR) return stat; 00962 return NC_put_vars(ncid, varid, startp, countp, 00963 stridep,(void*)op,NC_BYTE); 00964 } 00965 00966 int 00967 nc_put_vars_uchar(int ncid, int varid, 00968 const size_t *startp, const size_t *countp, 00969 const ptrdiff_t *stridep, 00970 const unsigned char *op) 00971 { 00972 NC *ncp; 00973 int stat = NC_check_id(ncid, &ncp); 00974 if(stat != NC_NOERR) return stat; 00975 return NC_put_vars(ncid, varid, startp, countp, 00976 stridep, (void *)op, T_uchar); 00977 } 00978 00979 int 00980 nc_put_vars_short(int ncid, int varid, 00981 const size_t *startp, const size_t *countp, 00982 const ptrdiff_t *stridep, 00983 const short *op) 00984 { 00985 NC *ncp; 00986 int stat = NC_check_id(ncid, &ncp); 00987 if(stat != NC_NOERR) return stat; 00988 return NC_put_vars(ncid, varid, startp, countp, 00989 stridep, (void *)op, NC_SHORT); 00990 } 00991 00992 int 00993 nc_put_vars_int(int ncid, int varid, 00994 const size_t *startp, const size_t *countp, 00995 const ptrdiff_t *stridep, 00996 const int *op) 00997 { 00998 NC *ncp; 00999 int stat = NC_check_id(ncid, &ncp); 01000 if(stat != NC_NOERR) return stat; 01001 return NC_put_vars(ncid, varid, startp, countp, 01002 stridep, (void *)op, NC_INT); 01003 } 01004 01005 int 01006 nc_put_vars_long(int ncid, int varid, 01007 const size_t *startp, const size_t *countp, 01008 const ptrdiff_t *stridep, 01009 const long *op) 01010 { 01011 NC *ncp; 01012 int stat = NC_check_id(ncid, &ncp); 01013 if(stat != NC_NOERR) return stat; 01014 return NC_put_vars(ncid, varid, startp, countp, 01015 stridep, (void *)op, T_long); 01016 } 01017 01018 int 01019 nc_put_vars_float(int ncid, int varid, 01020 const size_t *startp, const size_t *countp, 01021 const ptrdiff_t *stridep, 01022 const float *op) 01023 { 01024 NC *ncp; 01025 int stat = NC_check_id(ncid, &ncp); 01026 if(stat != NC_NOERR) return stat; 01027 return NC_put_vars(ncid, varid, startp, countp, 01028 stridep, (void *)op, T_float); 01029 } 01030 01031 int 01032 nc_put_vars_double(int ncid, int varid, 01033 const size_t *startp, const size_t *countp, 01034 const ptrdiff_t *stridep, 01035 const double *op) 01036 { 01037 NC *ncp; 01038 int stat = NC_check_id(ncid, &ncp); 01039 if(stat != NC_NOERR) return stat; 01040 return NC_put_vars(ncid, varid, startp, countp, 01041 stridep, (void *)op, T_double); 01042 } 01043 01044 int 01045 nc_put_vars_ubyte(int ncid, int varid, 01046 const size_t *startp, const size_t *countp, 01047 const ptrdiff_t *stridep, 01048 const unsigned char *op) 01049 { 01050 NC *ncp; 01051 int stat = NC_check_id(ncid, &ncp); 01052 if(stat != NC_NOERR) return stat; 01053 return NC_put_vars(ncid, varid, startp, countp, 01054 stridep, (void *)op, T_ubyte); 01055 } 01056 01057 int 01058 nc_put_vars_ushort(int ncid, int varid, 01059 const size_t *startp, const size_t *countp, 01060 const ptrdiff_t *stridep, 01061 const unsigned short *op) 01062 { 01063 NC *ncp; 01064 int stat = NC_check_id(ncid, &ncp); 01065 if(stat != NC_NOERR) return stat; 01066 return NC_put_vars(ncid, varid, startp, countp, 01067 stridep, (void *)op, T_ushort); 01068 } 01069 01070 int 01071 nc_put_vars_uint(int ncid, int varid, 01072 const size_t *startp, const size_t *countp, 01073 const ptrdiff_t *stridep, 01074 const unsigned int *op) 01075 { 01076 NC *ncp; 01077 int stat = NC_check_id(ncid, &ncp); 01078 if(stat != NC_NOERR) return stat; 01079 return NC_put_vars(ncid, varid, startp, countp, 01080 stridep, (void *)op, T_uint); 01081 } 01082 01083 int 01084 nc_put_vars_longlong(int ncid, int varid, 01085 const size_t *startp, const size_t *countp, 01086 const ptrdiff_t *stridep, 01087 const long long *op) 01088 { 01089 NC *ncp; 01090 int stat = NC_check_id(ncid, &ncp); 01091 if(stat != NC_NOERR) return stat; 01092 return NC_put_vars(ncid, varid, startp, countp, 01093 stridep, (void *)op, T_longlong); 01094 } 01095 01096 int 01097 nc_put_vars_ulonglong(int ncid, int varid, 01098 const size_t *startp, const size_t *countp, 01099 const ptrdiff_t *stridep, 01100 const unsigned long long *op) 01101 { 01102 NC *ncp; 01103 int stat = NC_check_id(ncid, &ncp); 01104 if(stat != NC_NOERR) return stat; 01105 return NC_put_vars(ncid, varid, startp, countp, 01106 stridep, (void *)op, NC_UINT64); 01107 } 01108 01109 #ifdef USE_NETCDF4 01110 int 01111 nc_put_vars_string(int ncid, int varid, 01112 const size_t *startp, const size_t *countp, 01113 const ptrdiff_t *stridep, 01114 const char**op) 01115 { 01116 NC *ncp; 01117 int stat = NC_check_id(ncid, &ncp); 01118 if(stat != NC_NOERR) return stat; 01119 return NC_put_vars(ncid, varid, startp, countp, stridep, 01120 (void *)op, NC_STRING); 01121 } 01122 #endif /*USE_NETCDF4*/ 01123 01158 int 01159 nc_put_varm (int ncid, int varid, const size_t *startp, 01160 const size_t *countp, const ptrdiff_t *stridep, 01161 const ptrdiff_t *imapp, const void *op) 01162 { 01163 NC *ncp; 01164 int stat = NC_NOERR; 01165 01166 if ((stat = NC_check_id(ncid, &ncp))) 01167 return stat; 01168 return ncp->dispatch->put_varm(ncid, varid, startp, countp, 01169 stridep, imapp, op, NC_NAT); 01170 } 01171 01172 int 01173 nc_put_varm_text(int ncid, int varid, const size_t *startp, 01174 const size_t *countp, const ptrdiff_t *stridep, 01175 const ptrdiff_t *imapp, const char *op) 01176 { 01177 NC *ncp; 01178 int stat = NC_check_id(ncid, &ncp); 01179 if(stat != NC_NOERR) return stat; 01180 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01181 (void *)op, NC_CHAR); 01182 } 01183 01184 int 01185 nc_put_varm_schar(int ncid, int varid, 01186 const size_t *startp, const size_t *countp, 01187 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01188 const signed char *op) 01189 { 01190 NC *ncp; 01191 int stat = NC_check_id(ncid, &ncp); 01192 if(stat != NC_NOERR) return stat; 01193 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01194 (void *)op, NC_BYTE); 01195 } 01196 01197 int 01198 nc_put_varm_uchar(int ncid, int varid, 01199 const size_t *startp, const size_t *countp, 01200 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01201 const unsigned char *op) 01202 { 01203 NC *ncp; 01204 int stat = NC_check_id(ncid, &ncp); 01205 if(stat != NC_NOERR) return stat; 01206 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01207 (void *)op, T_uchar); 01208 } 01209 01210 int 01211 nc_put_varm_short(int ncid, int varid, 01212 const size_t *startp, const size_t *countp, 01213 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01214 const short *op) 01215 { 01216 NC *ncp; 01217 int stat = NC_check_id(ncid, &ncp); 01218 if(stat != NC_NOERR) return stat; 01219 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01220 (void *)op, NC_SHORT); 01221 } 01222 01223 int 01224 nc_put_varm_int(int ncid, int varid, 01225 const size_t *startp, const size_t *countp, 01226 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01227 const int *op) 01228 { 01229 NC *ncp; 01230 int stat = NC_check_id(ncid, &ncp); 01231 if(stat != NC_NOERR) return stat; 01232 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01233 (void *)op, NC_INT); 01234 } 01235 01236 int 01237 nc_put_varm_long(int ncid, int varid, 01238 const size_t *startp, const size_t *countp, 01239 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01240 const long *op) 01241 { 01242 NC *ncp; 01243 int stat = NC_check_id(ncid, &ncp); 01244 if(stat != NC_NOERR) return stat; 01245 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01246 (void *)op, T_long); 01247 } 01248 01249 int 01250 nc_put_varm_float(int ncid, int varid, 01251 const size_t *startp, const size_t *countp, 01252 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01253 const float *op) 01254 { 01255 NC *ncp; 01256 int stat = NC_check_id(ncid, &ncp); 01257 if(stat != NC_NOERR) return stat; 01258 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01259 (void *)op, T_float); 01260 } 01261 01262 int 01263 nc_put_varm_double(int ncid, int varid, 01264 const size_t *startp, const size_t *countp, 01265 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01266 const double *op) 01267 { 01268 NC *ncp; 01269 int stat = NC_check_id(ncid, &ncp); 01270 if(stat != NC_NOERR) return stat; 01271 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01272 (void *)op, T_double); 01273 } 01274 01275 int 01276 nc_put_varm_ubyte(int ncid, int varid, 01277 const size_t *startp, const size_t *countp, 01278 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01279 const unsigned char *op) 01280 { 01281 NC *ncp; 01282 int stat = NC_check_id(ncid, &ncp); 01283 if(stat != NC_NOERR) return stat; 01284 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01285 (void *)op, T_ubyte); 01286 } 01287 01288 int 01289 nc_put_varm_ushort(int ncid, int varid, 01290 const size_t *startp, const size_t *countp, 01291 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01292 const unsigned short *op) 01293 { 01294 NC *ncp; 01295 int stat = NC_check_id(ncid, &ncp); 01296 if(stat != NC_NOERR) return stat; 01297 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01298 (void *)op, T_ushort); 01299 } 01300 01301 int 01302 nc_put_varm_uint(int ncid, int varid, 01303 const size_t *startp, const size_t *countp, 01304 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01305 const unsigned int *op) 01306 { 01307 NC *ncp; 01308 int stat = NC_check_id(ncid, &ncp); 01309 if(stat != NC_NOERR) return stat; 01310 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01311 (void *)op, T_uint); 01312 } 01313 01314 int 01315 nc_put_varm_longlong(int ncid, int varid, 01316 const size_t *startp, const size_t *countp, 01317 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01318 const long long *op) 01319 { 01320 NC *ncp; 01321 int stat = NC_check_id(ncid, &ncp); 01322 if(stat != NC_NOERR) return stat; 01323 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01324 (void *)op, T_longlong); 01325 } 01326 01327 int 01328 nc_put_varm_ulonglong(int ncid, int varid, 01329 const size_t *startp, const size_t *countp, 01330 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01331 const unsigned long long *op) 01332 { 01333 NC *ncp; 01334 int stat = NC_check_id(ncid, &ncp); 01335 if(stat != NC_NOERR) return stat; 01336 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01337 (void *)op, NC_UINT64); 01338 } 01339 01340 #ifdef USE_NETCDF4 01341 int 01342 nc_put_varm_string(int ncid, int varid, 01343 const size_t *startp, const size_t *countp, 01344 const ptrdiff_t *stridep, const ptrdiff_t *imapp, 01345 const char**op) 01346 { 01347 NC *ncp; 01348 int stat = NC_check_id(ncid, &ncp); 01349 if(stat != NC_NOERR) return stat; 01350 return NC_put_varm(ncid, varid, startp, countp, stridep, imapp, 01351 (void *)op, NC_STRING); 01352 } 01353 #endif /*USE_NETCDF4*/ 01354 /*End of named group... */ 01358