This is netcdf-cxx.info, produced by makeinfo version 4.12 from
/machine/netcdf/nc_test_30749/man4//defines.texi.
Copyright (C) 2005-2009 University Corporation for Atmospheric Research
Permission is granted to make and distribute verbatim copies of this
manual provided that the copyright notice and these paragraphs are
preserved on all copies. The software and any accompanying written
materials are provided "as is" without warranty of any kind. UCAR
expressly disclaims all warranties of any kind, either expressed or
implied, including but not limited to the implied warranties of
merchantability and fitness for a particular purpose.
The Unidata Program Center is managed by the University Corporation
for Atmospheric Research and sponsored by the National Science
Foundation. Any opinions, findings, conclusions, or recommendations
expressed in this publication are those of the author(s) and do not
necessarily reflect the views of the National Science Foundation.
Mention of any commercial company or product in this document does
not constitute an endorsement by the Unidata Program Center. Unidata
does not authorize any use of information from this publication for
advertising or publicity purposes.
INFO-DIR-SECTION netCDF scientific data format
START-INFO-DIR-ENTRY
* netcdf-cxx: (netcdf-cxx). The NetCDF C++ Interface Guide
END-INFO-DIR-ENTRY
File: netcdf-cxx.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir)
The NetCDF C++ Interface Guide
******************************
This document describes the netCDF C++ API. It applies to netCDF
version 4.1.1 release of the software, but the C++ interface still only
supports the "classic" data model from the netCDF-3 release. This
document was last updated in 6 August 2008.
The netCDF library provides an application- and machine-independent
interface to self-describing, array-oriented data. It supports an
abstract view of such data as a collection of named variables and their
attributes, and provides high-level access to data that is faithful to
the abstraction. This on-line document describes the C++ interface to
netCDF. This C++ interface is still based on the classic data model
supported by netCDF-3 software; it has not yet been updated to the
enhanced data model supported by netCDF-4.
The first part of this master menu lists the major nodes in this Info
document. The rest of the menu lists all the lower level nodes in the
document.
For a complete description of the netCDF format and utilities see
*note Top: (netcdf)Top.
* Menu:
* Introduction::
* NetCDF Classes::
* Auxiliary Classes::
* Combined Index::
--- The Detailed Node Listing ---
Introduction
* Class Hierarchy::
* Auxiliary Types and Constants::
NetCDF Classes
* Class NcFile:: Files
* Class NcDim:: Dimensions
* Class NcTypedComponent:: Operations common to variables and attributes
* Class NcVar:: Variables
* Class NcAtt:: Attributes
Auxiliary Classes
* Class NcValues::
* Class NcError::
File: netcdf-cxx.info, Node: Introduction, Next: NetCDF Classes, Prev: Top, Up: Top
Introduction
************
The main requirements for the design of the C++ interface are:
* to provide the functionality of the C interface;
* to provide type safety by eliminating all use of `void*' pointers;
and
* to provide an interface that is simpler to use than the C
interface.
Some of the features of the C++ interface are:
* No IDs needed for netCDF's variables, dimensions, or attributes.
* No explicit open or close calls needed for netCDF files; a
constructor opens and a destructor closes a file.
* No need to specify types for creating attributes; they will have
the type of the value provided.
* No use of `void*': values are type-checked.
* Less indirection is needed for dimensions and dimension sizes than
with the C interface. A variable's dimensions can be provided as
arguments when defining a variable.
* Code for data types is isolated to make the addition of new types
easier.
* No explicit `ncredef' or `ncendef' calls are needed for switching
between define and data modes. Whenever a mode switch is
required, it happens implicitly.
The header file `netcdfcpp.h' must be included in source code files
using this interface.
This release provides some of the functionality of netCDF version 4,
but not for the enhanced data model introduced with netCDF-4.
This manual assumes familiarity with the netCDF User's Guide, where
the concepts of netCDF dimensions, variables, and attributes are
discussed.
* Menu:
* Class Hierarchy::
* Auxiliary Types and Constants::
File: netcdf-cxx.info, Node: Class Hierarchy, Next: Auxiliary Types and Constants, Prev: Introduction, Up: Introduction
Class Hierarchy
===============
The class for netCDF file objects is `NcFile'.
The components of a netCDF file are dimensions, variables, and
attributes. There is a class for each of these kinds of objects;
`NcDim', `NcVar', and `NcAtt'. Variables and attributes share some
common characteristics that are factored out in the abstract base class
`NcTypedComponent'.
An auxiliary class, `NcValues', provides a type for arrays of values
that are read from or written to netCDF files. Another auxiliary class,
`NcError', provides facilities for handling errors.
`NcFile' netCDF file
`NcDim' dimension
`NcTypedComponent' abstract base class
`NcVar' variable
`NcAtt' attribute
`NcValues' abstract base class for array
`NcValues_ncbyte' array of bytes
`NcValues_char' array of characters
`NcValues_short' array of shorts
`NcValues_int' array of ints
`NcValues_long' array of longs
`NcValues_float' array of floats
`NcValues_double' array of doubles
`NcError' for error handling
File: netcdf-cxx.info, Node: Auxiliary Types and Constants, Prev: Class Hierarchy, Up: Introduction
Auxiliary Types and Constants
=============================
The netCDF classes use several auxiliary types for arguments and return
types from member functions: `NcToken', `NcType', `NcBool', and
`ncbyte'.
`NcToken'
Used for names for netCDF objects, in particular variable names,
dimension names, and attribute names. Currently this is just a
typedef for `const char*'.
`NcType'
Used for specifying netCDF external value types. Currently this
is an enumerated type with the following legitimate values:
`ncByte', `ncChar', `ncShort', `ncInt', `ncLong' (deprecated),
`ncFloat', and `ncDouble'.
`NcBool'
Used for the return type of some member functions. If the member
function fails, 0 is returned, otherwise some non-zero value.
Currently this is just a typedef for `unsigned int'. It will be
changed to `bool' when all C++ compilers support the new `bool'
type.
`ncbyte'
Used to declare values of type `ncByte', for 8-bit integer data.
(This is currently a typedef for `unsigned char', but it may be
changed to a typedef for `signed char', so don't depend on the
underlying representation.)
File: netcdf-cxx.info, Node: NetCDF Classes, Next: Auxiliary Classes, Prev: Introduction, Up: Top
NetCDF Classes
**************
* Menu:
* Class NcFile:: Files
* Class NcDim:: Dimensions
* Class NcTypedComponent:: Operations common to variables and attributes
* Class NcVar:: Variables
* Class NcAtt:: Attributes
File: netcdf-cxx.info, Node: Class NcFile, Next: Class NcDim, Prev: NetCDF Classes, Up: NetCDF Classes
Class NcFile
============
`NcFile' is the class for netCDF files, providing methods for netCDF
file operations.
Some member functions return pointers to dimensions (`NcDim') or
variables (`NcVar'). These objects are owned by the `NcFile' they are
associated with, and will be deleted automatically by the `NcFile'
destructor (or by the `close' member function, if this is called
earlier than the destructor), so users should not delete these. Member
functions that return pointers to attributes (`NcAtt') pass ownership
to the calling function; users should delete attributes when they are
finished with them.
Member functions that return `NcBool' yield `TRUE' on success and
`FALSE' on failure. Member functions that return a pointer value
return a `NULL' pointer on failure.
This class interface hides the distinction in the C and Fortran
interfaces between "define mode" (when dimensions, variables, or
attributes are being defined or renamed), and "data mode" (when data
values are being accessed), by automatically switching between the modes
when necessary. Be aware that switching from accessing data to adding
or renaming dimensions, variables and attributes can be expensive, since
it may entail a copy of the data.
Public Member Functions
-----------------------
`NcFile( const char * path, FileMode = ReadOnly, size_t *chunksizeptr = NULL, size_t initialsize = 0, FileFormat = Classic)'
The constructor creates a new netCDF file or opens an existing
netCDF file. The path argument may be an OPenDAP DAP URL if DAP
support is enabled.
The `FileMode' argument can be any of `ReadOnly' (the default) to
open an existing file for reading, `Write' to open an existing
file for reading or writing, `Replace' to create a new empty file
even if the named file already exists, or `New' to create a new
file only if the named file does not already exist.
The optional `FileFormat' argument can be any of `Classic' (the
default), `Offset64Bits', `Netcdf4', or `Netcdf4Classic'.
The optional `chunksizeptr' and `initialsize' tuning parameters
are as described in the corresponding `nc__create()' function in
the C interface.
The constructor will not fail, but in the case of a bad path name,
improper permissions, or if the file already exists and you have
specified `FileMode' as `New', no netCDF file will be created or
opened. If the constructor fails to create or open a netCDF file,
a subsequent call to the `is_valid()' member function will return
`False'.
`~NcFile( void )'
Destructor. The file is closed and all resources associated with
it are released, including the associated `NcVar' and `NcDim'
objects. If you wish to close the file earlier, you may
explicitly call the `close' member function; a subsequent
destructor call will work properly.
`NcBool close( void )'
Close netCDF file earlier than it would be closed by the `NcFile'
destructor.
`NcBool is_valid( void ) const'
Returns `TRUE' if valid netCDF file, `FALSE' otherwise (e.g. if
constructor could not open file).
`int num_dims( void ) const'
Returns the number of dimensions in the netCDF file.
`int num_vars( void ) const'
Returns the number of variables in the netCDF file.
`int num_atts( void ) const'
Returns the number of global attributes in the netCDF file.
`NcDim* get_dim(NcToken name) const'
Get a dimension by name.
`NcVar* get_var(NcToken name) const'
Get a variable by name.
`NcAtt* get_att(NcToken name) const'
Get a global attribute by name.
`NcDim* get_dim(int n) const'
Get the Nth dimension (beginning with the 0th).
`NcVar* get_var(int n) const'
Get the Nth variable (beginning with the 0th).
`NcAtt* get_att(int n) const'
Get the Nth global attribute (beginning with the 0th).
`NcDim* rec_dim( void ) const'
Get the unlimited dimension, if any.
The following `add_' member functions put the file in "define mode",
so could be expensive. To avoid copying of data, invoke these before
writing data to variables.
`NcDim* add_dim(NcToken dimname)'
Add an unlimited dimension named `dimname' to the netCDF file.
`NcDim* add_dim(NcToken dimname, long dimsize)'
Add a dimension named `dimname' of size `dimsize'.
`NcVar* add_var(NcToken varname, NcType type, const NcDim*, ...)'
Add a variable named `varname' of the specified type (`ncByte',
`ncChar', `ncShort', `ncInt', `ncFloat', `ncDouble') to the open
netCDF file. The variable is defined with a shape that depends on
how many dimension arguments are provided. A scalar variable
would have 0 dimensions, a vector would have 1 dimension, and so
on. Supply as many dimensions as needed, up to 5. If more than 5
dimensions are required, use the n-dimensional version of this
member function instead.
`NcVar* add_var(NcToken varname, NcType type, int ndims, const NcDim** dims)'
Add a variable named `varname' of `ndims' dimensions and of the
specified type. This method must be used when dealing with
variables of more than 5 dimensions.
`NcBool add_att(NcToken name, ncbyte val)'
`NcBool add_att(NcToken name, char val)'
`NcBool add_att(NcToken name, short val)'
`NcBool add_att(NcToken name, int val)'
`NcBool add_att(NcToken name, float val)'
`NcBool add_att(NcToken name, double val)'
Add global scalar attributes of the specified name and with the
supplied value.
`NcBool add_att(NcToken name, const char* val)'
Add global string-valued attribute with the specified name and C
string value (terminated with a `\0' character).
`NcBool add_att(NcToken name, int n, const ncbyte* val)'
`NcBool add_att(NcToken name, int n, const char* val)'
`NcBool add_att(NcToken name, int n, const short* val)'
`NcBool add_att(NcToken name, int n, const int* val)'
`NcBool add_att(NcToken name, int n, const float* val)'
`NcBool add_att(NcToken name, int n, const double* val)'
Add global vector attributes with the specified name, length, and
values.
`NcBool set_fill(FillMode mode = Fill)'
Sets fill-mode to either `NcFile::Fill' or `NcFile::NoFill'.
Default is `Fill', in which case unwritten values are pre-written
with appropriate type-specific or variable-specific fill values.
`enum NcFile::FillMode get_fill( void ) const'
Returns fill mode of the file, either `NcFile::Fill' or
`NcFile::NoFill'.
`enum NcFile::FileFormat get_format( void ) const'
Returns format version of the file, either `NcFile::Classic',
`NcFile:Offset64Bits', `NcFile:Netcdf4', or
`NcFile::Netcdf4Classic'.
`NcBool sync( void )'
Synchronizes file to disk. This flushes buffers so that readers
of the file will see recent changes.
`NcBool abort( void )'
Either just closes file (if recently it has been in data mode as
the result of accessing data), or backs out of the most recent
sequence of changes to the file schema (dimensions, variables, and
attributes).
File: netcdf-cxx.info, Node: Class NcDim, Next: Class NcTypedComponent, Prev: Class NcFile, Up: NetCDF Classes
Class NcDim
===========
A netCDF dimension has a name and a size. Dimensions are only created
and destroyed by NcFile member functions, because they cannot exist
independently of an open netCDF file. Hence there are no public
constructors or destructors.
Public Member Functions
-----------------------
`NcToken name( void ) const'
Returns the name of the dimension if it exists, 0 otherwise.
`long size( void ) const'
Returns the dimension size.
`NcBool is_valid( void ) const'
Returns `TRUE' if file and dimension are both valid, `FALSE'
otherwise.
`NcBool is_unlimited( void ) const'
Returns `TRUE' if the dimension is the unlimited dimension,
`FALSE' if either not a valid netCDF file, or if the dimension is
not the unlimited dimension.
`NcBool rename( NcToken newname )'
Renames the dimension to `newname'.
`NcBool sync( void )'
If the dimension may have been renamed, make sure its name is
updated.
File: netcdf-cxx.info, Node: Class NcTypedComponent, Next: Class NcVar, Prev: Class NcDim, Up: NetCDF Classes
Class NcTypedComponent
======================
`NcTypedComponent' is an abstract base class for `NcVar' and `NcAtt'
that captures the similarities between netCDF variables and attributes.
We list here the member functions that variables and attributes inherit
from `NcTypedComponent', but these member functions are also documented
under the `NcVar' and `NcAtt' classes for convenience.
Public Member Functions
-----------------------
`NcToken name( void ) const'
Returns the name of the variable or attribute.
`NcType type( void ) const'
Returns the type of the variable or attribute. The type will be
one of `ncByte', `ncChar', `ncShort', `ncInt', `ncFloat', or
`ncDouble'.
`NcBool is_valid( void ) const'
Returns `TRUE' if the component is valid, `FALSE' otherwise.
`long num_vals( void ) const'
Returns the number of values for an attribute or variable. For an
attribute, this is just 1 for a scalar attribute, the number of
values for a vector-valued attribute, and the number of characters
for a string-valued attribute. For a variable, this is the
product of the dimension sizes for all the variable's dimensions.
`NcBool rename( NcToken newname )'
Renames the variable or attribute.
`NcValues* values( void ) const'
Returns a pointer to the block of all values for the variable or
attribute. The caller is responsible for deleting this block of
values when no longer needed, as well as the pointer returned by
the `values' method. Note that this is not a good way to read
selected values of a variable; use the `get' member function
instead, to get single values or selected cross-sections of values.
`ncbyte as_ncbyte( int n ) const'
`char as_char( int n ) const'
`short as_short( int n ) const'
`int as_int( int n ) const'
`nclong as_nclong( int n ) const // deprecated'
`long as_long( int n ) const'
`float as_float( int n ) const'
`double as_double( int n ) const'
`char* as_string( int n ) const'
Get the n-th value of the attribute or variable. These member
functions provide conversions from the value type of the variable
or attribute to the specified type. If the value is out-of-range,
the fill-value of the appropriate type is returned.
File: netcdf-cxx.info, Node: Class NcVar, Next: Class NcAtt, Prev: Class NcTypedComponent, Up: NetCDF Classes
Class NcVar
===========
`NcVar' is derived from NcTypedComponent, and represents a netCDF
variable. A netCDF variable has a name, a type, a shape, zero or more
attributes, and a block of values associated with it. Because variables
are only associated with open netCDF files, there are no public
constructors for this class. Use member functions of `NcFile' to get
variables or add new variables.
Public Member Functions
-----------------------
`NcToken name( void ) const'
Returns the name of the variable.
`NcType type( void ) const'
Returns the type of the variable. The type will be one of
`ncByte', `ncChar', `ncShort', `ncInt', `ncFloat', or `ncDouble'.
`int num_dims( void ) const'
Returns number of dimensions for this variable.
`NcDim* get_dim( int n ) const'
Returns a pointer to the n-th dimension (starting at 0). Returns a
NULL-pointer if an invalid dimension is requested.
`long* edges( void ) const'
Returns the shape of the variable, in the form of a vector
containing the sizes of the dimensions of the variable. The
caller is responsible for deleting the returned edge vector when
no longer needed.
`int num_atts( void ) const'
Returns the number of attributes attached to the variable.
`NcAtt* get_att( NcToken attname ) const'
`NcAtt* get_att( int n ) const'
The first member function returns a variable attribute by name.
The second returns the n-th (starting at 0) attribute of the
variable. In either case, if no such attribute has been attached
to the variable, zero is returned. Attributes returned in this
way belong to the caller, and hence should eventually be deleted
by the caller to avoid memory leaks.
`NcBool is_valid( void ) const'
Returns `TRUE' if the variable is valid, `FALSE' otherwise.
`long num_vals( void ) const'
Returns the number of values for a variable. This is just 1 for a
scalar variable, or the product of the dimension sizes for all the
variable's dimensions.
`NcValues* values( void ) const'
Returns a pointer to the block of all values for the variable.
The caller is responsible for deleting this block of values when
no longer needed. Note that this is not a good way to read
selected values of a variable; use the `get' member function
instead, to get single values or selected cross-sections of values.
`NcBool put(const ncbyte* vals, long c0, long c1, long c2, long c3, long c4)'
`NcBool put(const char* vals, long c0, long c1, long c2, long c3, long c4)'
`NcBool put(const short* vals, long c0, long c1, long c2, long c3, long c4)'
`NcBool put(const int* vals, long c0, long c1, long c2, long c3, long c4)'
`NcBool put(const long* vals, long c0, long c1, long c2, long c3, long c4)'
`NcBool put(const float* vals, long c0, long c1, long c2, long c3, long c4)'
`NcBool put(const double* vals, long c0, long c1, long c2, long c3, long c4)'
Write scalar or 1 to 5-dimensional arrays by providing enough
arguments. Arguments are edge lengths, and their number must not
exceed variable's dimensionality. Start corner is `[0,0,..., 0]'
by default, but may be reset using the `set_cur()' member function
for this variable. `FALSE' is returned if type of values does not
match type for variable. For more than 5 dimensions, use the
overloaded n-dimensional form of the `put' member function.
`NcBool put(const ncbyte* vals, const long* counts)'
`NcBool put(const char* vals, const long* counts)'
`NcBool put(const short* vals, const long* counts)'
`NcBool put(const int* vals, const long* counts)'
`NcBool put(const long* vals, const long* counts)'
`NcBool put(const float* vals, const long* counts)'
`NcBool put(const double* vals, const long* counts)'
Write n-dimensional arrays, starting at `[0, 0, ..., 0]' by
default, may be reset with `set_cur()'. `FALSE' is returned if
type of values does not match type for variable.
`NcBool get(ncbyte* vals, long c0, long c1, long c2, long c3, long c4) const'
`NcBool get(char* vals, long c0, long c1, long c2, long c3, long c4) const'
`NcBool get(short* vals, long c0, long c1, long c2, long c3, long c4) const'
`NcBool get(int* vals, long c0, long c1, long c2, long c3, long c4) const'
`NcBool get(long* vals, long c0, long c1, long c2, long c3, long c4) const'
`NcBool get(float* vals, long c0, long c1, long c2, long c3, long c4) const'
`NcBool get(double* vals, long c0, long c1, long c2, long c3, long c4) const'
Get scalar or 1 to 5 dimensional arrays by providing enough
arguments. Arguments are edge lengths, and their number must not
exceed variable's dimensionality. Start corner is `[0,0,..., 0]'
by default, but may be reset using the `set_cur()' member
function. `FALSE' is returned if type of values does not match
type for variable.
`NcBool get(ncbyte* vals, const long* counts) const'
`NcBool get(char* vals, const long* counts) const'
`NcBool get(short* vals, const long* counts) const'
`NcBool get(int* vals, const long* counts) const'
`NcBool get(long* vals, const long* counts) const'
`NcBool get(float* vals, const long* counts) const'
`NcBool get(double* vals, const long* counts) const'
Get n-dimensional arrays, starting at `[0, 0, ..., 0]' by default,
may be reset with `set_cur()' member function. `FALSE' is
returned if type of values does not match type for variable.
`NcBool set_cur(long c0=-1, long c1=-1, long c2=-1, long c3=-1, long c4=-1)'
`NcBool set_cur(long* cur)'
Resets the starting corner to the values supplied. The first form
works for a variable of dimensionality from scalar to 5
dimensions. For more than five dimensions, use the second form,
in which the number of longs supplied must match the rank of the
variable. The method returns FALSE if any argument is greater
than the size of the corresponding dimension.
`NcBool add_att( NcToken, char )'
`NcBool add_att( NcToken, ncbyte )'
`NcBool add_att( NcToken, short )'
`NcBool add_att( NcToken, int )'
`NcBool add_att( NcToken, long )'
`NcBool add_att( NcToken, float )'
`NcBool add_att( NcToken, double )'
`NcBool add_att( NcToken, const char* )'
`NcBool add_att( NcToken, int, const char* )'
`NcBool add_att( NcToken, int, const ncbyte* )'
`NcBool add_att( NcToken, int, const short* )'
`NcBool add_att( NcToken, int, const int* )'
`NcBool add_att( NcToken, int, const long* )'
`NcBool add_att( NcToken, int, const float* )'
`NcBool add_att( NcToken, int, const double* )'
Add scalar or vector attribute of any type to a variable, given the
name, number of values, and the vector of values. These put file
in define mode, so could be expensive. To avoid the expense of
copying data, add attributes to variables before writing data.
`NcBool rename( NcToken newname )'
Renames the variable. If variable is renamed to a longer name,
this puts file in define mode, so could be expensive.
`ncbyte as_ncbyte( int n ) const'
`char as_char( int n ) const'
`short as_short( int n ) const'
`int as_int( int n ) const'
`nclong as_nclong( int n ) const // deprecated'
`long as_long( int n ) const'
`float as_float( int n ) const'
`double as_double( int n ) const'
`char* as_string( int n ) const'
Get the n-th value of the variable, ignoring its shape. These
member functions provide conversions from the value type of the
variable to the specified type. If the requested value is
out-of-range, the fill-value of the appropriate type is returned.
`int id( void ) const'
Return the variable number. This is not needed in the C++
interface, but might be needed in calling a C-function that
requires that a variable be identified by number instead of name.
`NcBool sync( void )'
If the variable may have been renamed, make sure its name is
updated.
`~NcVar( void )'
Destructor.
The following member functions are intended for record variables.
They will also work for non-record variables, if the first dimension is
interpreted as the record dimension.
`long rec_size( void )'
`long rec_size( NcDim* )'
Return the number of values per record or the number of values per
dimension slice for the specified dimension.
`NcValues* get_rec( void )'
`NcValues* get_rec( long n )'
Get the data for this variable for the current record or for the
Nth record.
`NcValues* get_rec( NcDim* )'
`NcValues* get_rec( NcDim*, long n )'
Get the data for this variable for the current dimension slice or
for the Nth dimension slice.
`NcBool put_rec( const ncbyte* vals )'
`NcBool put_rec( const char* vals )'
`NcBool put_rec( const short* vals )'
`NcBool put_rec( const int* vals )'
`NcBool put_rec( const long* vals )'
`NcBool put_rec( const float* vals )'
`NcBool put_rec( const double* vals )'
Put a record's worth of data for this variable in the current
record.
`NcBool put_rec( NcDim*, const ncbyte* vals )'
`NcBool put_rec( NcDim*, const char* vals )'
`NcBool put_rec( NcDim*, const short* vals )'
`NcBool put_rec( NcDim*, const int* vals )'
`NcBool put_rec( NcDim*, const long* vals )'
`NcBool put_rec( NcDim*, const float* vals )'
`NcBool put_rec( NcDim*, const double* vals )'
Put a dimension slice worth of data for this variable in the
current dimension slice.
`NcBool put_rec( const ncbyte* vals, long rec )'
`NcBool put_rec( const char* vals, long rec )'
`NcBool put_rec( const short* vals, long rec )'
`NcBool put_rec( const int* vals, long rec )'
`NcBool put_rec( const long* vals, long rec )'
`NcBool put_rec( const float* vals, long rec )'
`NcBool put_rec( const double* vals, long rec )'
Put a record's worth of data for this variable in the specified
record.
`NcBool put_rec( NcDim*, const ncbyte* vals, long slice )'
`NcBool put_rec( NcDim*, const char* vals, long slice )'
`NcBool put_rec( NcDim*, const short* vals, long slice )'
`NcBool put_rec( NcDim*, const int* vals, long slice )'
`NcBool put_rec( NcDim*, const long* vals, long slice )'
`NcBool put_rec( NcDim*, const float* vals, long slice )'
`NcBool put_rec( NcDim*, const double* vals, long slice )'
Put a dimension slice worth of data for this variable in the
specified dimension slice.
`long get_index( const ncbyte* vals )'
`long get_index( const char* vals )'
`long get_index( const short* vals )'
`long get_index( const int* vals )'
`long get_index( const long* vals )'
`long get_index( const float* vals )'
`long get_index( const double* vals )'
Get first record index for this variable corresponding to the
specified key value(s).
`long get_index( NcDim*, const ncbyte* vals )'
`long get_index( NcDim*, const char* vals )'
`long get_index( NcDim*, const short* vals )'
`long get_index( NcDim*, const int* vals )'
`long get_index( NcDim*, const long* vals )'
`long get_index( NcDim*, const float* vals )'
`long get_index( NcDim*, const double* vals )'
Get first index of specified dimension for this variable
corresponding to the specified key value(s).
`void set_rec ( long rec )'
Set the current record for this variable.
`void set_rec ( NcDim*, long rec )'
Set the current dimension slice for the specified dimension for
this variable.
File: netcdf-cxx.info, Node: Class NcAtt, Prev: Class NcVar, Up: NetCDF Classes
Class NcAtt
===========
`NcAtt' is derived from `NcTypedComponent', and represents a netCDF
attribute. A netCDF attribute has a name and a type, and may be either
a scalar attribute or a vector attribute. Scalar attributes have one
value and vector attributes have multiple values. In addition, each
attribute is attached to a specific netCDF variable or is global to an
entire netCDF file. Because attributes are only associated with open
netCDF files, there are no public constructors for this class. Use
member functions of `NcFile' and `NcVar' to get netCDF attributes or
add new attributes. Most of the useful member functions for `NcAtt' are
inherited from class `NcTypedComponent'.
Public Member Functions
-----------------------
`NcToken name( void ) const'
Returns the name of the attribute.
`NcType type( void ) const'
Returns the type of the attribute. The type will be one of
`ncByte', `ncChar', `ncShort', `ncInt', `ncFloat', or `ncDouble'.
`NcBool is_valid( void ) const'
Returns `TRUE' if the attribute is valid, `FALSE' otherwise.
`long num_vals( void ) const'
Returns the number of values for an attribute. This is just 1 for
a scalar attribute, the number of values for a vector-valued
attribute, and the number of characters for a string-valued
attribute.
`NcBool rename( NcToken newname )'
Renames the attribute.
`NcValues* values( void ) const'
Returns a pointer to the block of all values for the attribute.
The caller is responsible for deleting this block of values when
no longer needed.
`ncbyte as_ncbyte( int n ) const'
`char as_char( int n ) const'
`short as_short( int n ) const'
`int as_int( int n ) const'
`nclong as_nclong( int n ) const // deprecated'
`long as_long( int n ) const'
`float as_float( int n ) const'
`double as_double( int n ) const'
`char* as_string( int n ) const'
Get the n-th value of the attribute. These member functions
provide conversions from the value type of the attribute to the
specified type. If the value is out-of-range, the fill-value of
the appropriate type is returned.
`NcBool remove( void )'
Deletes the attribute from the file and detaches it from the
variable. Does not call the destructor. Subsequent calls to
`is_valid()' will return `FALSE'.
`~NcAtt( void )'
Destructor.
File: netcdf-cxx.info, Node: Auxiliary Classes, Next: Combined Index, Prev: NetCDF Classes, Up: Top
Auxiliary Classes
*****************
Auxiliary classes include the abstract base class `NcValues', its
type-specific derived subclasses, and the error-handling class
`NcError'.
* Menu:
* Class NcValues::
* Class NcError::
File: netcdf-cxx.info, Node: Class NcValues, Next: Class NcError, Prev: Auxiliary Classes, Up: Auxiliary Classes
Class NcValues
==============
Class `NcValues' is an abstract base class for a block of typed values.
The derived classes are `NcValues_ncbyte', `NcValues_char',
`NcValues_short', `NcValues_int', `NcValues_nclong' (deprecated), and
`NcValues_long', `NcValues_float', `NcValues_double'. These classes
are used as the return type of the `NcTypedComponent::values()' member
function, for typed-value arrays associated with variables and
attributes.
Public Member Functions
-----------------------
`NcValues( void )'
Default constructor.
`NcValues(NcType, long)'
Constructor for a value block of the specified type and length.
`~NcValues( void )'
Destructor.
`long num( void )'
Returns the number of values in the value block.
`ostream& print(ostream&) const'
Used to print the comma-delimited sequence of values of the value
block.
`void* base( void ) const'
Returns a bland pointer to the beginning of the value block.
`int bytes_for_one( void ) const'
Returns the number of bytes required for one value.
`ncbyte as_ncbyte( int n ) const'
`char as_char( int n ) const'
`short as_short( int n ) const'
`int as_int( int n ) const'
`nclong as_nclong( int n ) const // deprecated'
`long as_long( int n ) const'
`float as_float( int n ) const'
`double as_double( int n ) const'
`char* as_string( int n ) const'
Provide conversions for the nth value from the value type to a
desired basic type. If the value is out of range, the default
"fill-value" for the appropriate type is returned.
File: netcdf-cxx.info, Node: Class NcError, Prev: Class NcValues, Up: Auxiliary Classes
Class NcError
=============
This class provides control for netCDF error handling. Declaring an
`NcError' object temporarily changes the error-handling behavior for
all netCDF classes until the `NcError' object is destroyed (typically
by going out of scope), at which time the previous error-handling
behavior is restored.
Public Member Functions
-----------------------
`NcError( Behavior b = verbose_fatal )'
The constructor saves the previous error state for restoration
when the destructor is invoked, and sets a new specified state.
Valid error states are `NcError::silent_nonfatal',
`NcError::verbose_nonfatal', `NcError::silent_fatal', or
`NcError::verbose_fatal', to control whether error messages are
output from the underlying library and whether such messages are
fatal or nonfatal.
`~NcError( void )'
Destructor, restores previous error state.
`int get_err( void )'
Returns most recent error, as enumerated in `netcdf.h'.
File: netcdf-cxx.info, Node: Combined Index, Prev: Auxiliary Classes, Up: Top
Index
*****
孩湤數
* Menu:
* abort: Class NcFile. (line 168)
* add_att <1>: Class NcVar. (line 124)
* add_att: Class NcFile. (line 128)
* add_dim: Class NcFile. (line 107)
* add_var: Class NcFile. (line 113)
* as_char <1>: Class NcValues. (line 40)
* as_char <2>: Class NcAtt. (line 45)
* as_char <3>: Class NcVar. (line 150)
* as_char: Class NcTypedComponent.
(line 45)
* as_double <1>: Class NcValues. (line 46)
* as_double <2>: Class NcAtt. (line 51)
* as_double <3>: Class NcVar. (line 156)
* as_double: Class NcTypedComponent.
(line 51)
* as_float <1>: Class NcValues. (line 45)
* as_float <2>: Class NcAtt. (line 50)
* as_float <3>: Class NcVar. (line 155)
* as_float: Class NcTypedComponent.
(line 50)
* as_int <1>: Class NcValues. (line 42)
* as_int <2>: Class NcAtt. (line 47)
* as_int <3>: Class NcVar. (line 152)
* as_int: Class NcTypedComponent.
(line 47)
* as_long <1>: Class NcValues. (line 44)
* as_long <2>: Class NcAtt. (line 49)
* as_long <3>: Class NcVar. (line 154)
* as_long: Class NcTypedComponent.
(line 49)
* as_ncbyte <1>: Class NcValues. (line 39)
* as_ncbyte <2>: Class NcAtt. (line 44)
* as_ncbyte <3>: Class NcVar. (line 149)
* as_ncbyte: Class NcTypedComponent.
(line 44)
* as_nclong <1>: Class NcValues. (line 43)
* as_nclong <2>: Class NcAtt. (line 48)
* as_nclong <3>: Class NcVar. (line 153)
* as_nclong: Class NcTypedComponent.
(line 48)
* as_short <1>: Class NcValues. (line 41)
* as_short <2>: Class NcAtt. (line 46)
* as_short <3>: Class NcVar. (line 151)
* as_short: Class NcTypedComponent.
(line 46)
* as_string <1>: Class NcValues. (line 47)
* as_string <2>: Class NcAtt. (line 52)
* as_string <3>: Class NcVar. (line 157)
* as_string: Class NcTypedComponent.
(line 52)
* auxiliary types and constants: Auxiliary Types and Constants.
(line 6)
* base: Class NcValues. (line 33)
* bytes_for_one: Class NcValues. (line 36)
* class hierarchy: Class Hierarchy. (line 6)
* close: Class NcFile. (line 65)
* edges: Class NcVar. (line 30)
* get: Class NcVar. (line 90)
* get_att <1>: Class NcVar. (line 39)
* get_att: Class NcFile. (line 88)
* get_dim <1>: Class NcVar. (line 26)
* get_dim: Class NcFile. (line 82)
* get_err: Class NcError. (line 27)
* get_fill: Class NcFile. (line 155)
* get_format: Class NcFile. (line 159)
* get_index: Class NcVar. (line 235)
* get_rec: Class NcVar. (line 185)
* get_var: Class NcFile. (line 85)
* id: Class NcVar. (line 163)
* is_unlimited: Class NcDim. (line 24)
* is_valid <1>: Class NcAtt. (line 27)
* is_valid <2>: Class NcVar. (line 49)
* is_valid <3>: Class NcTypedComponent.
(line 23)
* is_valid <4>: Class NcDim. (line 20)
* is_valid: Class NcFile. (line 69)
* name <1>: Class NcAtt. (line 20)
* name <2>: Class NcVar. (line 16)
* name <3>: Class NcTypedComponent.
(line 15)
* name: Class NcDim. (line 14)
* NcAtt: Class NcVar. (line 263)
* NcAtt::remove: Class NcAtt. (line 58)
* NcAtt::~NcAtt: Class NcAtt. (line 63)
* NcBool: Auxiliary Types and Constants.
(line 21)
* ncbyte: Auxiliary Types and Constants.
(line 28)
* NcDim: Class NcFile. (line 174)
* NcDim::is_unlimited: Class NcDim. (line 24)
* NcDim::is_valid: Class NcDim. (line 20)
* NcDim::name: Class NcDim. (line 14)
* NcDim::rename: Class NcDim. (line 29)
* NcDim::size: Class NcDim. (line 17)
* NcDim::sync: Class NcDim. (line 32)
* NcError <1>: Class NcError. (line 15)
* NcError: Class NcValues. (line 52)
* NcError::get_err: Class NcError. (line 27)
* NcError::~NcError: Class NcError. (line 24)
* NcFile <1>: Class NcFile. (line 33)
* NcFile: NetCDF Classes. (line 14)
* NcFile::abort: Class NcFile. (line 168)
* NcFile::add_att: Class NcFile. (line 128)
* NcFile::add_dim: Class NcFile. (line 107)
* NcFile::add_var: Class NcFile. (line 113)
* NcFile::close: Class NcFile. (line 65)
* NcFile::get_att: Class NcFile. (line 88)
* NcFile::get_dim: Class NcFile. (line 82)
* NcFile::get_fill: Class NcFile. (line 155)
* NcFile::get_format: Class NcFile. (line 159)
* NcFile::get_var: Class NcFile. (line 85)
* NcFile::is_valid: Class NcFile. (line 69)
* NcFile::NcFile: Class NcFile. (line 33)
* NcFile::num_atts: Class NcFile. (line 79)
* NcFile::num_dims: Class NcFile. (line 73)
* NcFile::num_vars: Class NcFile. (line 76)
* NcFile::rec_dim: Class NcFile. (line 100)
* NcFile::set_fill: Class NcFile. (line 150)
* NcFile::sync: Class NcFile. (line 164)
* NcFile::~NcFile: Class NcFile. (line 58)
* NcToken: Auxiliary Types and Constants.
(line 10)
* NcType: Auxiliary Types and Constants.
(line 15)
* NcTypedComponent: Class NcDim. (line 37)
* NcTypedComponent::as_char <1>: Class NcAtt. (line 45)
* NcTypedComponent::as_char <2>: Class NcVar. (line 150)
* NcTypedComponent::as_char: Class NcTypedComponent.
(line 45)
* NcTypedComponent::as_double <1>: Class NcAtt. (line 51)
* NcTypedComponent::as_double <2>: Class NcVar. (line 156)
* NcTypedComponent::as_double: Class NcTypedComponent.
(line 51)
* NcTypedComponent::as_float <1>: Class NcAtt. (line 50)
* NcTypedComponent::as_float <2>: Class NcVar. (line 155)
* NcTypedComponent::as_float: Class NcTypedComponent.
(line 50)
* NcTypedComponent::as_int <1>: Class NcAtt. (line 47)
* NcTypedComponent::as_int <2>: Class NcVar. (line 152)
* NcTypedComponent::as_int: Class NcTypedComponent.
(line 47)
* NcTypedComponent::as_long <1>: Class NcAtt. (line 49)
* NcTypedComponent::as_long <2>: Class NcVar. (line 154)
* NcTypedComponent::as_long: Class NcTypedComponent.
(line 49)
* NcTypedComponent::as_ncbyte <1>: Class NcAtt. (line 44)
* NcTypedComponent::as_ncbyte <2>: Class NcVar. (line 149)
* NcTypedComponent::as_ncbyte: Class NcTypedComponent.
(line 44)
* NcTypedComponent::as_nclong <1>: Class NcAtt. (line 48)
* NcTypedComponent::as_nclong <2>: Class NcVar. (line 153)
* NcTypedComponent::as_nclong: Class NcTypedComponent.
(line 48)
* NcTypedComponent::as_short <1>: Class NcAtt. (line 46)
* NcTypedComponent::as_short <2>: Class NcVar. (line 151)
* NcTypedComponent::as_short: Class NcTypedComponent.
(line 46)
* NcTypedComponent::as_string <1>: Class NcAtt. (line 52)
* NcTypedComponent::as_string <2>: Class NcVar. (line 157)
* NcTypedComponent::as_string: Class NcTypedComponent.
(line 52)
* NcTypedComponent::is_valid <1>: Class NcAtt. (line 27)
* NcTypedComponent::is_valid <2>: Class NcVar. (line 49)
* NcTypedComponent::is_valid: Class NcTypedComponent.
(line 23)
* NcTypedComponent::name <1>: Class NcAtt. (line 20)
* NcTypedComponent::name <2>: Class NcVar. (line 16)
* NcTypedComponent::name: Class NcTypedComponent.
(line 15)
* NcTypedComponent::num_vals <1>: Class NcAtt. (line 30)
* NcTypedComponent::num_vals <2>: Class NcVar. (line 52)
* NcTypedComponent::num_vals: Class NcTypedComponent.
(line 26)
* NcTypedComponent::rename <1>: Class NcAtt. (line 36)
* NcTypedComponent::rename <2>: Class NcVar. (line 145)
* NcTypedComponent::rename: Class NcTypedComponent.
(line 33)
* NcTypedComponent::type <1>: Class NcAtt. (line 23)
* NcTypedComponent::type <2>: Class NcVar. (line 19)
* NcTypedComponent::type: Class NcTypedComponent.
(line 18)
* NcTypedComponent::values <1>: Class NcAtt. (line 39)
* NcTypedComponent::values <2>: Class NcVar. (line 57)
* NcTypedComponent::values: Class NcTypedComponent.
(line 36)
* NcValues <1>: Class NcValues. (line 17)
* NcValues: Auxiliary Classes. (line 15)
* NcValues::as_char: Class NcValues. (line 40)
* NcValues::as_double: Class NcValues. (line 46)
* NcValues::as_float: Class NcValues. (line 45)
* NcValues::as_int: Class NcValues. (line 42)
* NcValues::as_long: Class NcValues. (line 44)
* NcValues::as_ncbyte: Class NcValues. (line 39)
* NcValues::as_nclong: Class NcValues. (line 43)
* NcValues::as_short: Class NcValues. (line 41)
* NcValues::as_string: Class NcValues. (line 47)
* NcValues::base: Class NcValues. (line 33)
* NcValues::bytes_for_one: Class NcValues. (line 36)
* NcValues::NcValues: Class NcValues. (line 17)
* NcValues::num: Class NcValues. (line 26)
* NcValues::print: Class NcValues. (line 29)
* NcValues::~NcValues: Class NcValues. (line 23)
* NcValues_char: Class NcValues. (line 6)
* NcValues_double: Class NcValues. (line 6)
* NcValues_float: Class NcValues. (line 6)
* NcValues_int: Class NcValues. (line 6)
* NcValues_long: Class NcValues. (line 6)
* NcValues_ncbyte: Class NcValues. (line 6)
* NcValues_nclong: Class NcValues. (line 6)
* NcValues_short: Class NcValues. (line 6)
* NcVar: Class NcTypedComponent.
(line 58)
* NcVar::add_att: Class NcVar. (line 124)
* NcVar::edges: Class NcVar. (line 30)
* NcVar::get: Class NcVar. (line 90)
* NcVar::get_att: Class NcVar. (line 39)
* NcVar::get_dim: Class NcVar. (line 26)
* NcVar::get_index: Class NcVar. (line 235)
* NcVar::get_rec: Class NcVar. (line 185)
* NcVar::id: Class NcVar. (line 163)
* NcVar::num_atts: Class NcVar. (line 36)
* NcVar::num_dims: Class NcVar. (line 23)
* NcVar::put: Class NcVar. (line 64)
* NcVar::put_rec: Class NcVar. (line 195)
* NcVar::rec_size: Class NcVar. (line 179)
* NcVar::set_cur: Class NcVar. (line 115)
* NcVar::set_rec: Class NcVar. (line 255)
* NcVar::sync: Class NcVar. (line 168)
* NcVar::~NcVar: Class NcVar. (line 172)
* num: Class NcValues. (line 26)
* num_atts <1>: Class NcVar. (line 36)
* num_atts: Class NcFile. (line 79)
* num_dims <1>: Class NcVar. (line 23)
* num_dims: Class NcFile. (line 73)
* num_vals <1>: Class NcAtt. (line 30)
* num_vals <2>: Class NcVar. (line 52)
* num_vals: Class NcTypedComponent.
(line 26)
* num_vars: Class NcFile. (line 76)
* print: Class NcValues. (line 29)
* put: Class NcVar. (line 64)
* put_rec: Class NcVar. (line 195)
* rec_dim: Class NcFile. (line 100)
* rec_size: Class NcVar. (line 179)
* remove: Class NcAtt. (line 58)
* rename <1>: Class NcAtt. (line 36)
* rename <2>: Class NcVar. (line 145)
* rename <3>: Class NcTypedComponent.
(line 33)
* rename: Class NcDim. (line 29)
* requirements of C++ interface: Introduction. (line 6)
* set_cur: Class NcVar. (line 115)
* set_fill: Class NcFile. (line 150)
* set_rec: Class NcVar. (line 255)
* size: Class NcDim. (line 17)
* sync <1>: Class NcVar. (line 168)
* sync <2>: Class NcDim. (line 32)
* sync: Class NcFile. (line 164)
* type <1>: Class NcAtt. (line 23)
* type <2>: Class NcVar. (line 19)
* type: Class NcTypedComponent.
(line 18)
* values <1>: Class NcAtt. (line 39)
* values <2>: Class NcVar. (line 57)
* values: Class NcTypedComponent.
(line 36)
* ~NcAtt: Class NcAtt. (line 63)
* ~NcError: Class NcError. (line 24)
* ~NcFile: Class NcFile. (line 58)
* ~NcValues: Class NcValues. (line 23)
* ~NcVar: Class NcVar. (line 172)
Tag Table:
Node: Top1388
Node: Introduction3074
Node: Class Hierarchy4757
Node: Auxiliary Types and Constants6178
Node: NetCDF Classes7467
Node: Class NcFile7857
Node: Class NcDim15058
Node: Class NcTypedComponent16144
Node: Class NcVar18538
Node: Class NcAtt29970
Node: Auxiliary Classes32424
Node: Class NcValues32756
Node: Class NcError34424
Node: Combined Index35504
End Tag Table
