netCDF 4.2.1.1
/usr/src/RPM/BUILD/libnetcdf7-seq-4.2.1.1/libdispatch/dvarput.c
Go to the documentation of this file.
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 
 All Data Structures Files Functions Variables Typedefs Defines

Generated on Tue Aug 6 2013 11:40:56 for netCDF. NetCDF is a Unidata library.