Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Search for 

ncdf4a13/cxx/netcdf.cpp File Reference

#include <config.h>
#include <string.h>
#include <stdlib.h>
#include "netcdfcpp.h"

Include dependency graph for netcdf.cpp:

Go to the source code of this file.

Defines

#define TRUE   1
#define FALSE   0
#define NcFile_add_scalar_att(TYPE)
#define NcFile_add_vector_att(TYPE)
#define Nc_as(TYPE)   name2(as_,TYPE)
#define NcTypedComponent_as(TYPE)
#define NcVar_put_rec(TYPE)
#define NcVar_get_index(TYPE)
#define NcVar_put_array(TYPE)
#define NcVar_put_nd_array(TYPE)
#define NcVar_get_array(TYPE)
#define NcVar_get_nd_array(TYPE)
#define NcVar_add_scalar_att(TYPE)
#define NcVar_add_vector_att(TYPE)

Functions

 NcFile_add_scalar_att (char) NcFile_add_scalar_att(ncbyte) NcFile_add_scalar_att(short) NcFile_add_scalar_att(int) NcFile_add_scalar_att(long) NcFile_add_scalar_att(float) NcFile_add_scalar_att(double) NcFile_add_scalar_att(const char *) NcFile_add_vector_att(char) NcFile_add_vector_att(ncbyte) NcFile_add_vector_att(short) NcFile_add_vector_att(int) NcFile_add_vector_att(long) NcFile_add_vector_att(float) NcFile_add_vector_att(double) NcBool NcFile
 NcTypedComponent_as (ncbyte) NcTypedComponent_as(char) NcTypedComponent_as(short) NcTypedComponent_as(int) NcTypedComponent_as(nclong) NcTypedComponent_as(long) NcTypedComponent_as(float) NcTypedComponent_as(double) char *NcTypedComponent
 NcVar_put_rec (ncbyte) NcVar_put_rec(char) NcVar_put_rec(short) NcVar_put_rec(int) NcVar_put_rec(long) NcVar_put_rec(float) NcVar_put_rec(double) long NcVar
 NcVar_get_index (ncbyte) NcVar_get_index(char) NcVar_get_index(short) NcVar_get_index(nclong) NcVar_get_index(long) NcVar_get_index(float) NcVar_get_index(double) NcVar_put_array(ncbyte) NcVar_put_array(char) NcVar_put_array(short) NcVar_put_array(int) NcVar_put_array(long) NcVar_put_array(float) NcVar_put_array(double) NcVar_put_nd_array(ncbyte) NcVar_put_nd_array(char) NcVar_put_nd_array(short) NcVar_put_nd_array(int) NcVar_put_nd_array(long) NcVar_put_nd_array(float) NcVar_put_nd_array(double) NcVar_get_array(ncbyte) NcVar_get_array(char) NcVar_get_array(short) NcVar_get_array(int) NcVar_get_array(long) NcVar_get_array(float) NcVar_get_array(double) NcVar_get_nd_array(ncbyte) NcVar_get_nd_array(char) NcVar_get_nd_array(short) NcVar_get_nd_array(int) NcVar_get_nd_array(long) NcVar_get_nd_array(float) NcVar_get_nd_array(double) NcBool NcVar
 NcVar_add_scalar_att (char) NcVar_add_scalar_att(ncbyte) NcVar_add_scalar_att(short) NcVar_add_scalar_att(int) NcVar_add_scalar_att(long) NcVar_add_scalar_att(double) NcBool NcVar
 NcVar_add_vector_att (char) NcVar_add_vector_att(ncbyte) NcVar_add_vector_att(short) NcVar_add_vector_att(int) NcVar_add_vector_att(long) NcVar_add_vector_att(float) NcVar_add_vector_att(double) NcBool NcVar

Variables

static const int ncGlobal = NC_GLOBAL
static const int ncBad = -1

Define Documentation

#define FALSE   0
 

Definition at line 17 of file netcdf.cpp.

Referenced by NcVar::add_att(), NcFile::data_mode(), NcFile::define_mode(), NcDim::is_unlimited(), NcVar_add_scalar_att(), NcVar_add_vector_att(), NcVar_get_index(), NcAtt::remove(), NcAtt::rename(), NcDim::rename(), NcVar::set_cur(), NcVar::sync(), and NcDim::sync().

#define Nc_as (  TYPE   )     name2(as_,TYPE)
 

Definition at line 475 of file netcdf.cpp.

#define NcFile_add_scalar_att (  TYPE   ) 
 

Value:

NcBool NcFile::add_att(NcToken aname, TYPE val)                               \
{                                                                             \
    return globalv->add_att(aname, val);                                      \
}

Definition at line 179 of file netcdf.cpp.

#define NcFile_add_vector_att (  TYPE   ) 
 

Value:

NcBool NcFile::add_att(NcToken aname, int n, const TYPE* val)                 \
{                                                                             \
    return globalv->add_att(aname, n, val);                                   \
}

#define NcTypedComponent_as (  TYPE   ) 
 

Value:

TYPE NcTypedComponent::Nc_as(TYPE)( long n ) const                        \
{                                                                         \
  NcValues* tmp = values();                                               \
  TYPE rval = tmp->Nc_as(TYPE)(n);                                        \
  delete tmp;                                                             \
  return rval;                                                            \
}

Definition at line 476 of file netcdf.cpp.

#define NcVar_add_scalar_att (  TYPE   ) 
 

Value:

NcBool NcVar::add_att(NcToken aname, TYPE val)                                \
{                                                                             \
    if (! the_file->define_mode())                                            \
      return FALSE;                                                           \
    if (ncattput(the_file->id(), the_id, aname, (nc_type) NcTypeEnum(TYPE),   \
                 1, &val) == ncBad)                                           \
      return FALSE;                                                           \
    return TRUE;                                                              \
}                                                                             \

Definition at line 968 of file netcdf.cpp.

#define NcVar_add_vector_att (  TYPE   ) 
 

Value:

NcBool NcVar::add_att(NcToken aname, int len, const TYPE* vals)               \
{                                                                             \
    if (! the_file->define_mode())                                            \
      return FALSE;                                                           \
    if (ncattput(the_file->id(), the_id, aname, (nc_type) NcTypeEnum(TYPE),   \
                 len, vals) == ncBad)                                         \
      return FALSE;                                                           \
    return TRUE;                                                              \
}

Definition at line 1007 of file netcdf.cpp.

#define NcVar_get_array (  TYPE   ) 
 

Value:

NcBool NcVar::get( TYPE* vals,                                                \
                     long edge0,                                              \
                     long edge1,                                              \
                     long edge2,                                              \
                     long edge3,                                              \
                     long edge4) const                                        \
{                                                                             \
    if (type() != NcTypeEnum(TYPE))                                           \
      return FALSE;                                                           \
    if (! the_file->data_mode())                                              \
      return FALSE;                                                           \
    long count[5];                                                            \
    count[0] = edge0;                                                         \
    count[1] = edge1;                                                         \
    count[2] = edge2;                                                         \
    count[3] = edge3;                                                         \
    count[4] = edge4;                                                         \
    for (int i = 0; i < 5; i++) {                                             \
        if (count[i]) {                                                       \
            if (num_dims() < i)                                               \
              return FALSE;                                                   \
        } else                                                                \
          break;                                                              \
    }                                                                         \
    static long start[5] = {0, 0, 0, 0, 0};                                   \
    for (int j = 0; j < 5; j++) {                                             \
     start[j] = the_cur[j];                                                   \
    }                                                                         \
    return ncvarget(the_file->id(), the_id, start, count, vals) != ncBad;     \
}

#define NcVar_get_index (  TYPE   ) 
 

Value:

long NcVar::get_index(const TYPE* key)                                        \
{                                                                             \
   return get_index(get_dim(0), key);                                         \
}                                                                             \
                                                                              \
long NcVar::get_index(NcDim *rdim, const TYPE* key)                           \
{                                                                             \
if (type() != NcTypeEnum(TYPE))                                               \
    return -1;                                                                \
if (! the_file->data_mode())                                                  \
    return -1;                                                                \
int idx = dim_to_index(rdim);                                                 \
long maxrec = get_dim(idx)->size();                                           \
long maxvals = rec_size(rdim);                                                \
NcValues* val;                                                                \
int validx;                                                                   \
for (long j=0; j<maxrec; j++) {                                               \
    val = get_rec(rdim,j);                                                    \
    if (val == NULL) return -1;                                               \
    for (validx = 0; validx < maxvals; validx++) {                            \
        if (key[validx] != val->as_ ## TYPE(validx)) break;                   \
        }                                                                     \
    delete val;                                                               \
    if (validx == maxvals) return j;                                          \
    }                                                                         \
return -1;                                                                    \
}

Definition at line 768 of file netcdf.cpp.

#define NcVar_get_nd_array (  TYPE   ) 
 

Value:

NcBool NcVar::get( TYPE* vals, const long* count ) const                      \
{                                                                             \
    if (type() != NcTypeEnum(TYPE))                                           \
      return FALSE;                                                           \
    if (! the_file->data_mode())                                              \
      return FALSE;                                                           \
    long start[MAX_NC_DIMS];                                                  \
    for (int i = 0; i < num_dims(); i++)                                      \
        start[i] = the_cur[i];                                                \
    return ncvarget(the_file->id(), the_id, start, count, vals) != ncBad;     \
}

#define NcVar_put_array (  TYPE   ) 
 

Value:

NcBool NcVar::put( const TYPE* vals,                                          \
                     long edge0,                                              \
                     long edge1,                                              \
                     long edge2,                                              \
                     long edge3,                                              \
                     long edge4)                                              \
{                                                                             \
    if (type() != NcTypeEnum(TYPE))                                           \
      return FALSE;                                                           \
    if (! the_file->data_mode())                                              \
      return FALSE;                                                           \
    long count[5];                                                            \
    count[0] = edge0;                                                         \
    count[1] = edge1;                                                         \
    count[2] = edge2;                                                         \
    count[3] = edge3;                                                         \
    count[4] = edge4;                                                         \
    for (int i = 0; i < 5; i++) {                                             \
        if (count[i]) {                                                       \
            if (num_dims() < i)                                               \
              return FALSE;                                                   \
        } else                                                                \
          break;                                                              \
    }                                                                         \
    long start[5];                                                            \
    for (int j = 0; j < 5; j++) {                                             \
     start[j] = the_cur[j];                                                   \
    }                                                                         \
    return ncvarput(the_file->id(), the_id, start, count, vals) != ncBad;     \
}

#define NcVar_put_nd_array (  TYPE   ) 
 

Value:

NcBool NcVar::put( const TYPE* vals, const long* count )                      \
{                                                                             \
    if (type() != NcTypeEnum(TYPE))                                           \
      return FALSE;                                                           \
    if (! the_file->data_mode())                                              \
      return FALSE;                                                           \
    long start[MAX_NC_DIMS];                                                  \
    for (int i = 0; i < num_dims(); i++)                                      \
      start[i] = the_cur[i];                                                  \
    return ncvarput(the_file->id(), the_id, start, count, vals) != ncBad;     \
}

#define NcVar_put_rec (  TYPE   ) 
 

Definition at line 705 of file netcdf.cpp.

#define TRUE   1
 

Definition at line 16 of file netcdf.cpp.

Referenced by NcVar::add_att(), NcFile::data_mode(), NcFile::define_mode(), NcVar_add_scalar_att(), NcVar::set_cur(), NcVar::sync(), and NcDim::sync().

Function Documentation

NcFile_add_scalar_att (  char   )  const
 

Definition at line 185 of file netcdf.cpp.

00196 {                                                                             \
00197     return globalv->add_att(aname, n, val);                                   \
00198 }
00199 
00200 NcFile_add_vector_att(char)
00201 NcFile_add_vector_att(ncbyte)
00202 NcFile_add_vector_att(short)
00203 NcFile_add_vector_att(int)
00204 NcFile_add_vector_att(long)
00205 NcFile_add_vector_att(float)
00206 NcFile_add_vector_att(double)
00207 
00208 NcBool NcFile::set_fill( FillMode a_mode )
00209 {
00210   if (ncsetfill(the_id, a_mode) != ncBad) {
00211     the_fill_mode = a_mode;
00212     return TRUE;
00213   }
00214   return FALSE;
00215 }

NcTypedComponent_as (  ncbyte   ) 
 

Definition at line 484 of file netcdf.cpp.

References NcValues::as_string().

00494 {
00495     NcValues* tmp = values();
00496     char* rval = tmp->as_string(n);
00497     delete tmp;
00498     return rval;
00499 }

NcVar_add_scalar_att (  char   ) 
 

Definition at line 979 of file netcdf.cpp.

References FALSE, ncattput(), ncBad, ncFloat, and TRUE.

00987 {
00988     if (! the_file->define_mode())
00989       return FALSE;
00990     float fval = (float) val;   // workaround for bug, val passed as double??
00991     if (ncattput(the_file->id(), the_id, aname, (nc_type) ncFloat,
00992                  1, &fval) == ncBad)
00993       return FALSE;
00994     return TRUE;
00995 }

NcVar_add_vector_att (  char   ) 
 

Definition at line 1017 of file netcdf.cpp.

References FALSE, ncBad, and ncvarrename().

01026 {
01027     if (strlen(newname) > strlen(the_name)) {
01028         if (! the_file->define_mode())
01029             return FALSE;
01030     }
01031     NcBool ret = ncvarrename(the_file->id(), the_id, newname) != ncBad;
01032     if (ret) {
01033         delete [] the_name;
01034         the_name = new char [1 + strlen(newname)];
01035         strcpy(the_name, newname);
01036     }
01037     return ret;
01038 }

NcVar_get_index (  ncbyte   ) 
 

Definition at line 798 of file netcdf.cpp.

References FALSE, ncBad, NcTypeEnum, ncvarput(), num_dims, and type.

00814 {                                                                             \
00815     if (type() != NcTypeEnum(TYPE))                                           \
00816       return FALSE;                                                           \
00817     if (! the_file->data_mode())                                              \
00818       return FALSE;                                                           \
00819     long count[5];                                                            \
00820     count[0] = edge0;                                                         \
00821     count[1] = edge1;                                                         \
00822     count[2] = edge2;                                                         \
00823     count[3] = edge3;                                                         \
00824     count[4] = edge4;                                                         \
00825     for (int i = 0; i < 5; i++) {                                             \
00826         if (count[i]) {                                                       \
00827             if (num_dims() < i)                                               \
00828               return FALSE;                                                   \
00829         } else                                                                \
00830           break;                                                              \
00831     }                                                                         \
00832     long start[5];                                                            \
00833     for (int j = 0; j < 5; j++) {                                             \
00834      start[j] = the_cur[j];                                                   \
00835     }                                                                         \
00836     return ncvarput(the_file->id(), the_id, start, count, vals) != ncBad;     \
00837 }
00838 
00839 NcVar_put_array(ncbyte)
00840 NcVar_put_array(char)
00841 NcVar_put_array(short)
00842 NcVar_put_array(int)
00843 NcVar_put_array(long)
00844 NcVar_put_array(float)
00845 NcVar_put_array(double)
00846 
00847 #define NcVar_put_nd_array(TYPE)                                              \
00848 NcBool NcVar::put( const TYPE* vals, const long* count )                      \
00849 {                                                                             \
00850     if (type() != NcTypeEnum(TYPE))                                           \
00851       return FALSE;                                                           \
00852     if (! the_file->data_mode())                                              \
00853       return FALSE;                                                           \
00854     long start[MAX_NC_DIMS];                                                  \
00855     for (int i = 0; i < num_dims(); i++)                                      \
00856       start[i] = the_cur[i];                                                  \
00857     return ncvarput(the_file->id(), the_id, start, count, vals) != ncBad;     \
00858 }
00859 
00860 NcVar_put_nd_array(ncbyte)
00861 NcVar_put_nd_array(char)
00862 NcVar_put_nd_array(short)
00863 NcVar_put_nd_array(int)
00864 NcVar_put_nd_array(long)
00865 NcVar_put_nd_array(float)
00866 NcVar_put_nd_array(double)
00867 
00868 #define NcVar_get_array(TYPE)                                                 \
00869 NcBool NcVar::get( TYPE* vals,                                                \
00870                      long edge0,                                              \
00871                      long edge1,                                              \
00872                      long edge2,                                              \
00873                      long edge3,                                              \
00874                      long edge4) const                                        \
00875 {                                                                             \
00876     if (type() != NcTypeEnum(TYPE))                                           \
00877       return FALSE;                                                           \
00878     if (! the_file->data_mode())                                              \
00879       return FALSE;                                                           \
00880     long count[5];                                                            \
00881     count[0] = edge0;                                                         \
00882     count[1] = edge1;                                                         \
00883     count[2] = edge2;                                                         \
00884     count[3] = edge3;                                                         \
00885     count[4] = edge4;                                                         \
00886     for (int i = 0; i < 5; i++) {                                             \
00887         if (count[i]) {                                                       \
00888             if (num_dims() < i)                                               \
00889               return FALSE;                                                   \
00890         } else                                                                \
00891           break;                                                              \
00892     }                                                                         \
00893     static long start[5] = {0, 0, 0, 0, 0};                                   \
00894     for (int j = 0; j < 5; j++) {                                             \
00895      start[j] = the_cur[j];                                                   \
00896     }                                                                         \
00897     return ncvarget(the_file->id(), the_id, start, count, vals) != ncBad;     \
00898 }
00899 
00900 NcVar_get_array(ncbyte)
00901 NcVar_get_array(char)
00902 NcVar_get_array(short)
00903 NcVar_get_array(int)
00904 NcVar_get_array(long)
00905 NcVar_get_array(float)
00906 NcVar_get_array(double)
00907 
00908 #define NcVar_get_nd_array(TYPE)                                              \
00909 NcBool NcVar::get( TYPE* vals, const long* count ) const                      \
00910 {                                                                             \
00911     if (type() != NcTypeEnum(TYPE))                                           \
00912       return FALSE;                                                           \
00913     if (! the_file->data_mode())                                              \
00914       return FALSE;                                                           \
00915     long start[MAX_NC_DIMS];                                                  \
00916     for (int i = 0; i < num_dims(); i++)                                      \
00917         start[i] = the_cur[i];                                                \
00918     return ncvarget(the_file->id(), the_id, start, count, vals) != ncBad;     \
00919 }
00920 
00921 NcVar_get_nd_array(ncbyte)
00922 NcVar_get_nd_array(char)
00923 NcVar_get_nd_array(short)
00924 NcVar_get_nd_array(int)
00925 NcVar_get_nd_array(long)
00926 NcVar_get_nd_array(float)
00927 NcVar_get_nd_array(double)
00928 
00929 // If no args, set cursor to all zeros.  Else set initial elements of cursor
00930 // to args provided, rest to zeros.
00931 NcBool NcVar::set_cur(long c0, long c1, long c2, long c3, long c4)
00932 {
00933     long t[6];
00934     t[0] = c0;
00935     t[1] = c1;
00936     t[2] = c2;
00937     t[3] = c3;
00938     t[4] = c4;
00939     t[5] = -1;
00940     for(int j = 0; j < 6; j++) { // find how many parameters were used
00941         int i;
00942         if (t[j] == -1) {
00943             if (num_dims() < j)
00944               return FALSE;     // too many for variable's dimensionality
00945             for (i = 0; i < j; i++) {
00946                 if (t[i] >= get_dim(i)->size() && ! get_dim(i)->is_unlimited())
00947                   return FALSE; // too big for dimension
00948                 the_cur[i] = t[i];
00949             }
00950             for(i = j; i < num_dims(); i++)
00951               the_cur[i] = 0;
00952             return TRUE;
00953         }
00954     }
00955     return TRUE;
00956 }

NcVar_put_rec (  ncbyte   ) 
 

Definition at line 743 of file netcdf.cpp.

00751                          {
00752     return rec_size(get_dim(0));
00753 }

Variable Documentation

const int ncBad = -1 [static]
 

Definition at line 22 of file netcdf.cpp.

Referenced by NcFile::abort(), NcVar::add_att(), NcVar::attname(), NcFile::close(), NcFile::data_mode(), NcFile::define_mode(), NcVar::get_dim(), NcVar::get_rec(), NcAtt::is_valid(), NcVar::is_valid(), NcDim::is_valid(), NcFile::is_valid(), NcDim::NcDim(), NcFile::NcFile(), NcVar::NcVar(), NcVar_add_scalar_att(), NcVar_add_vector_att(), NcVar_get_index(), NcAtt::remove(), NcAtt::rename(), NcDim::rename(), NcVar::sync(), NcDim::sync(), NcFile::sync(), NcAtt::values(), and NcVar::values().

const int ncGlobal = NC_GLOBAL [static]
 

Definition at line 20 of file netcdf.cpp.

Referenced by NcFile::NcFile(), and NcVar::num_atts().

Generated on Thu Mar 16 18:10:22 2006 for nco by  doxygen 1.4.4