00358              {
00359         NCT_UNSPECIFIED = 0,
00360         NCT_UCHAR =     1,      /* unsigned char */
00361         NCT_TEXT =      16,     /* char */
00362 #define NCT_CHAR NCT_TEXT
00363         NCT_SCHAR =     17,     /* signed char */
00364         NCT_SHORT =     18,     /* short */
00365         NCT_INT =       20,     /* int */
00366         NCT_LONG =      22,     /* long */
00367         NCT_FLOAT =     36,     /* float */
00368         NCT_DOUBLE =    40      /* double */
00369 } nct_itype;

02215 {
02216         int status;
02217         NC_attr *attrp;
02218 
02219         status = NC_lookupattr(ncid, varid, name, &attrp);
02220         if(status != NC_NOERR)
02221                 return status;
02222 
02223         switch (attrp->type) {
02224         case NC_BYTE:
02225                 return nc_get_att_schar(ncid, varid, name,
02226                         (schar *)value);
02227         case NC_CHAR:
02228                 return nc_get_att_text(ncid, varid, name,
02229                         (char *)value);
02230         case NC_SHORT:
02231                 return nc_get_att_short(ncid, varid, name,
02232                         (short *)value);
02233         case NC_INT:
02234 #if (SIZEOF_INT >= X_SIZEOF_INT)
02235                 return nc_get_att_int(ncid, varid, name,
02236                         (int *)value);
02237 #elif SIZEOF_LONG == X_SIZEOF_INT
02238                 return nc_get_att_long(ncid, varid, name,
02239                         (long *)value);
02240 #endif
02241         case NC_FLOAT:
02242                 return nc_get_att_float(ncid, varid, name,
02243                         (float *)value);
02244         case NC_DOUBLE:
02245                 return nc_get_att_double(ncid, varid, name,
02246                         (double *)value);
02247         }
02248         return NC_EBADTYPE;
02249 }

04921 {
04922         int status;
04923         NC *ncp;
04924         const NC_var *varp;
04925 
04926         status = NC_check_id(ncid, &ncp); 
04927         if(status != NC_NOERR)
04928                 return status;
04929 
04930         varp = NC_lookupvar(ncp, varid);
04931         if(varp == NULL)
04932                 return NC_ENOTVAR;
04933 
04934         switch(varp->type){
04935         case NC_CHAR:
04936                 return nc_get_var1_text(ncid, varid, coord,
04937                         (char *) value);
04938         case NC_BYTE:
04939                 return nc_get_var1_schar(ncid, varid, coord,
04940                         (schar *) value);
04941         case NC_SHORT:
04942                 return nc_get_var1_short(ncid, varid, coord,
04943                         (short *) value);
04944         case NC_INT:
04945                 return nc_get_var1_int(ncid, varid, coord,
04946                         (int *) value);
04947         case NC_FLOAT:
04948                 return nc_get_var1_float(ncid, varid, coord,
04949                         (float *) value);
04950         case NC_DOUBLE: 
04951                 return nc_get_var1_double(ncid, varid, coord,
04952                         (double *) value);
04953         }
04954         return NC_EBADTYPE;
04955 }

06665 {
06666         int status;
06667         NC *ncp;
06668         const NC_var *varp;
06669 
06670         status = NC_check_id(ncid, &ncp); 
06671         if(status != NC_NOERR)
06672                 return status;
06673 
06674         if(NC_indef(ncp))
06675                 return NC_EINDEFINE;
06676 
06677         varp = NC_lookupvar(ncp, varid);
06678         if(varp == NULL)
06679                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
06680 
06681         switch(varp->type){
06682         case NC_CHAR:
06683                 return nc_get_vara_text(ncid, varid, start, edges,
06684                         (char *) value);
06685         case NC_BYTE:
06686                 return nc_get_vara_schar(ncid, varid, start, edges,
06687                         (schar *) value);
06688         case NC_SHORT:
06689                 return nc_get_vara_short(ncid, varid, start, edges,
06690                         (short *) value);
06691         case NC_INT:
06692 #if (SIZEOF_INT >= X_SIZEOF_INT)
06693                 return nc_get_vara_int(ncid, varid, start, edges,
06694                         (int *) value);
06695 #elif SIZEOF_LONG == X_SIZEOF_INT
06696                 return nc_get_vara_long(ncid, varid, start, edges,
06697                         (long *) value);
06698 #else
06699 #error "nc_get_vara implementation"
06700 #endif
06701         case NC_FLOAT:
06702                 return nc_get_vara_float(ncid, varid, start, edges,
06703                         (float *) value);
06704         case NC_DOUBLE: 
06705                 return nc_get_vara_double(ncid, varid, start, edges,
06706                         (double *) value);
06707         }
06708         return NC_EBADTYPE;
06709 }

09715 {
09716         int status;
09717         NC *ncp;
09718         const NC_var *varp;
09719         ptrdiff_t *cvtmap = NULL;
09720 
09721         status = NC_check_id(ncid, &ncp); 
09722         if(status != NC_NOERR)
09723                 return status;
09724 
09725         varp = NC_lookupvar(ncp, varid);
09726         if(varp == NULL)
09727                 return NC_ENOTVAR;
09728 
09729         if(map != NULL && varp->ndims != 0)
09730         {
09731                 /*
09732                  * convert map units from bytes to units of sizeof(type)
09733                  */
09734                 size_t ii;
09735                 const ptrdiff_t szof = (ptrdiff_t) nctypelen(varp->type);
09736                 cvtmap = (ptrdiff_t *)calloc(varp->ndims, sizeof(ptrdiff_t));
09737                 if(cvtmap == NULL)
09738                         return NC_ENOMEM;
09739                 for(ii = 0; ii < varp->ndims; ii++)
09740                 {
09741                         if(map[ii] % szof != 0) 
09742                         {
09743                                 free(cvtmap);
09744                                 return NC_EINVAL;
09745                         }
09746                         cvtmap[ii] = map[ii] / szof;
09747                 }
09748                 map = cvtmap;
09749         }
09750 
09751         switch(varp->type){
09752         case NC_CHAR:
09753                 status =  nc_get_varm_text(ncid, varid, start, edges,
09754                         stride, map,
09755                         (char *) value);
09756                 break;
09757         case NC_BYTE:
09758                 status = nc_get_varm_schar(ncid, varid, start, edges,
09759                         stride, map,
09760                         (schar *) value);
09761                 break;
09762         case NC_SHORT:
09763                 status = nc_get_varm_short(ncid, varid, start, edges,
09764                         stride, map,
09765                         (short *) value);
09766                 break;
09767         case NC_INT:
09768 #if (SIZEOF_INT >= X_SIZEOF_INT)
09769                 status = nc_get_varm_int(ncid, varid, start, edges,
09770                         stride, map,
09771                         (int *) value);
09772 #elif SIZEOF_LONG == X_SIZEOF_INT
09773                 status = nc_get_varm_long(ncid, varid, start, edges,
09774                         stride, map,
09775                         (long *) value);
09776 #else
09777 #error "nc_get_varm implementation"
09778 #endif
09779                 break;
09780         case NC_FLOAT:
09781                 status = nc_get_varm_float(ncid, varid, start, edges,
09782                         stride, map,
09783                         (float *) value);
09784                 break;
09785         case NC_DOUBLE: 
09786                 status = nc_get_varm_double(ncid, varid, start, edges,
09787                         stride, map,
09788                         (double *) value);
09789                 break;
09790         default:
09791                 status = NC_EBADTYPE;
09792                 break;
09793         }
09794 
09795         if(cvtmap != NULL)
09796         {
09797                 free(cvtmap);
09798         }
09799         return status;
09800 }

08076 {
08077         return nc_get_varm (ncid, varid, start, edges,
08078                          stride, 0, value);
08079 }

02182 {
02183         switch (type) {
02184         case NC_BYTE:
02185                 return nc_put_att_schar(ncid, varid, name, type, nelems,
02186                         (schar *)value);
02187         case NC_CHAR:
02188                 return nc_put_att_text(ncid, varid, name, nelems,
02189                         (char *)value);
02190         case NC_SHORT:
02191                 return nc_put_att_short(ncid, varid, name, type, nelems,
02192                         (short *)value);
02193         case NC_INT:
02194 #if (SIZEOF_INT >= X_SIZEOF_INT)
02195                 return nc_put_att_int(ncid, varid, name, type, nelems,
02196                         (int *)value);
02197 #elif SIZEOF_LONG == X_SIZEOF_INT
02198                 return nc_put_att_long(ncid, varid, name, type, nelems,
02199                         (long *)value);
02200 #endif
02201         case NC_FLOAT:
02202                 return nc_put_att_float(ncid, varid, name, type, nelems,
02203                         (float *)value);
02204         case NC_DOUBLE:
02205                 return nc_put_att_double(ncid, varid, name, type, nelems,
02206                         (double *)value);
02207         }
02208         return NC_EBADTYPE;
02209 }

04654 {
04655         int status;
04656         NC *ncp;
04657         const NC_var *varp;
04658 
04659         status = NC_check_id(ncid, &ncp); 
04660         if(status != NC_NOERR)
04661                 return status;
04662 
04663         varp = NC_lookupvar(ncp, varid);
04664         if(varp == NULL)
04665                 return NC_ENOTVAR;
04666 
04667         switch(varp->type){
04668         case NC_CHAR:
04669                 return nc_put_var1_text(ncid, varid, coord,
04670                         (const char *) value);
04671         case NC_BYTE:
04672                 return nc_put_var1_schar(ncid, varid, coord,
04673                         (const schar *) value);
04674         case NC_SHORT:
04675                 return nc_put_var1_short(ncid, varid, coord,
04676                         (const short *) value);
04677         case NC_INT:
04678                 return nc_put_var1_int(ncid, varid, coord,
04679                         (const int *) value);
04680         case NC_FLOAT:
04681                 return nc_put_var1_float(ncid, varid, coord,
04682                         (const float *) value);
04683         case NC_DOUBLE: 
04684                 return nc_put_var1_double(ncid, varid, coord,
04685                         (const double *) value);
04686         }
04687         return NC_EBADTYPE;
04688 }

05814 {
05815         int status;
05816         NC *ncp;
05817         const NC_var *varp;
05818 
05819         status = NC_check_id(ncid, &ncp); 
05820         if(status != NC_NOERR)
05821                 return status;
05822 
05823         if(NC_readonly(ncp))
05824                 return NC_EPERM;
05825 
05826         if(NC_indef(ncp))
05827                 return NC_EINDEFINE;
05828 
05829         varp = NC_lookupvar(ncp, varid);
05830         if(varp == NULL)
05831                 return NC_ENOTVAR; /* TODO: lost NC_EGLOBAL */
05832 
05833         switch(varp->type){
05834         case NC_CHAR:
05835                 return nc_put_vara_text(ncid, varid, start, edges,
05836                         (const char *) value);
05837         case NC_BYTE:
05838                 return nc_put_vara_schar(ncid, varid, start, edges,
05839                         (const schar *) value);
05840         case NC_SHORT:
05841                 return nc_put_vara_short(ncid, varid, start, edges,
05842                         (const short *) value);
05843         case NC_INT:
05844                 return nc_put_vara_int(ncid, varid, start, edges,
05845                         (const int *) value);
05846         case NC_FLOAT:
05847                 return nc_put_vara_float(ncid, varid, start, edges,
05848                         (const float *) value);
05849         case NC_DOUBLE: 
05850                 return nc_put_vara_double(ncid, varid, start, edges,
05851                         (const double *) value);
05852         }
05853         return NC_EBADTYPE;
05854 }

11276 {
11277         int status;
11278         NC *ncp;
11279         const NC_var *varp;
11280         ptrdiff_t *cvtmap = NULL;
11281 
11282         status = NC_check_id(ncid, &ncp); 
11283         if(status != NC_NOERR)
11284                 return status;
11285 
11286         varp = NC_lookupvar(ncp, varid);
11287         if(varp == NULL)
11288                 return NC_ENOTVAR;
11289 
11290         if(map != NULL && varp->ndims != 0)
11291         {
11292                 /*
11293                  * convert map units from bytes to units of sizeof(type)
11294                  */
11295                 size_t ii;
11296                 const ptrdiff_t szof = (ptrdiff_t) nctypelen(varp->type);
11297                 cvtmap = (ptrdiff_t *)calloc(varp->ndims, sizeof(ptrdiff_t));
11298                 if(cvtmap == NULL)
11299                         return NC_ENOMEM;
11300                 for(ii = 0; ii < varp->ndims; ii++)
11301                 {
11302                         if(map[ii] % szof != 0) 
11303                         {
11304                                 free(cvtmap);
11305                                 return NC_EINVAL;
11306                         }
11307                         cvtmap[ii] = map[ii] / szof;
11308                 }
11309                 map = cvtmap;
11310         }
11311 
11312         switch(varp->type){
11313         case NC_CHAR:
11314                 status =  nc_put_varm_text(ncid, varid, start, edges,
11315                         stride, map,
11316                         (const char *) value);
11317                 break;
11318         case NC_BYTE:
11319                 status = nc_put_varm_schar(ncid, varid, start, edges,
11320                         stride, map,
11321                         (const schar *) value);
11322                 break;
11323         case NC_SHORT:
11324                 status = nc_put_varm_short(ncid, varid, start, edges,
11325                         stride, map,
11326                         (const short *) value);
11327                 break;
11328         case NC_INT:
11329 #if (SIZEOF_INT >= X_SIZEOF_INT)
11330                 status = nc_put_varm_int(ncid, varid, start, edges,
11331                         stride, map,
11332                         (const int *) value);
11333 #elif SIZEOF_LONG == X_SIZEOF_INT
11334                 status = nc_put_varm_long(ncid, varid, start, edges,
11335                         stride, map,
11336                         (const long *) value);
11337 #else
11338 #error "nc_put_varm implementation"
11339 #endif
11340                 break;
11341         case NC_FLOAT:
11342                 status = nc_put_varm_float(ncid, varid, start, edges,
11343                         stride, map,
11344                         (const float *) value);
11345                 break;
11346         case NC_DOUBLE: 
11347                 status = nc_put_varm_double(ncid, varid, start, edges,
11348                         stride, map,
11349                         (const double *) value);
11350                 break;
11351         default:
11352                 status = NC_EBADTYPE;
11353                 break;
11354         }
11355 
11356         if(cvtmap != NULL)
11357         {
11358                 free(cvtmap);
11359         }
11360         return status;
11361 }

08197 {
08198         return nc_put_varm (ncid, varid, start, edges,
08199                          stride, 0, value);
08200 }

00843 {
00844         switch(type){
00845         case NC_BYTE :
00846         case NC_CHAR :
00847                 return((int)sizeof(char));
00848         case NC_SHORT :
00849                 return(int)(sizeof(short));
00850         case NC_INT :
00851                 return((int)sizeof(int));
00852         case NC_FLOAT :
00853                 return((int)sizeof(float));
00854         case NC_DOUBLE : 
00855                 return((int)sizeof(double));
00856         }
00857 
00858 #ifndef NO_NETCDF_2
00859         /* else */
00860         nc_advise("nctypelen", NC_EBADTYPE, "Unknown type %d",
00861                 (int)type);
00862 #endif /* NO_NETCDF_2 */
00863         return -1;
00864 }