NCStructure.cc

 
// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of nc_handler, a data handler for the OPeNDAP data
// server.
 
// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 2.1 of the License, or (at your
// option) any later version.
//
// This software is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
// License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
 
// (c) COPYRIGHT URI/MIT 1994-1996
// Please read the full copyright statement in the file COPYRIGHT.
//
// Authors:
//      reza            Reza Nekovei (reza@intcomm.net)
 
// netCDF sub-class implementation for NCByte,...NCGrid.
// The files are patterned after the subcalssing examples
// Test<type>.c,h files.
//
// ReZa 1/12/95
 
#include "config_nc.h"
 
static char rcsid[] not_used ={"$Id$"};
 
#include <vector>
#include <algorithm>
 
#include <netcdf.h>
 
#include <libdap/D4Attributes.h>
#include <libdap/util.h>
#include <libdap/InternalErr.h>
 
#include "nc_util.h"
#include "NCStructure.h"
#include "NCArray.h"
 
BaseType *
NCStructure::ptr_duplicate()
{
    return new NCStructure(*this);
}
 
NCStructure::NCStructure(const string &n, const string &d) : Structure(n, d)
{
}
 
NCStructure::NCStructure(const NCStructure &rhs) : Structure(rhs)
{
}
 
NCStructure::~NCStructure()
{
}
 
NCStructure &
NCStructure::operator=(const NCStructure &rhs)
{
    if (this == &rhs)
        return *this;
 
    dynamic_cast<Structure&>(*this) = rhs; // run Structure assignment
 
    return *this;
}

 
class AddAttribute: public unary_function<BaseType *, void> {
 
public:
    AddAttribute() {}
 
    void operator()(BaseType *a) {
        AttrTable *at;
        AttrTable::Attr_iter aiter;
        a->get_attr_table().find("translation", &at, &aiter);
        if (a->get_attr_table().attr_end() == aiter) {
            a->get_attr_table().append_attr("translation", "String",
                                            "\"flatten\"");
        }
    }
};

void NCStructure::transfer_attributes(AttrTable *at)
{
    if (at) {
        Vars_iter var = var_begin();
        while (var != var_end()) {
            (*var)->transfer_attributes(at);
            var++;
        }
    }
}

void
NCStructure::transform_to_dap4(D4Group *root, Constructor *container)
{
    Structure *dest = new NCStructure(name(), dataset());
    Constructor::transform_to_dap4(root, dest);
    container->add_var_nocopy(dest);
}
 
void NCStructure::do_structure_read(int ncid, int varid, nc_type datatype,
        vector<char> &values, bool has_values, int values_offset)
{
#if NETCDF_VERSION >= 4
  if (is_user_defined_type(ncid, datatype)) {
        char type_name[NC_MAX_NAME+1];
        size_t size;
        nc_type base_type;
        size_t nfields;
        int class_type;
        int errstat = nc_inq_user_type(ncid, datatype, type_name, &size, &base_type, &nfields, &class_type);
        if (errstat != NC_NOERR)
            throw InternalErr(__FILE__, __LINE__, "Could not get information about a user-defined type (" + long_to_string(errstat) + ").");
 
        switch (class_type) {
            case NC_COMPOUND: {
                if (!has_values) {
                    values.resize(size);
                    int errstat = nc_get_var(ncid, varid, values.data() /*values.data()*/);
                    if (errstat != NC_NOERR)
                        throw Error(errstat, string("Could not get the value for variable '") + name() + string("'"));
                    has_values = true;
                }
 
                for (size_t i = 0; i < nfields; ++i) {
                    char field_name[NC_MAX_NAME+1];
                    nc_type field_typeid;
                    size_t field_offset;
                    int field_ndims;
                    nc_inq_compound_field(ncid, datatype, i, field_name, &field_offset, &field_typeid, &field_ndims, 0);
                    if (is_user_defined_type(ncid, field_typeid)) {
                        // Interior user defined types have names, but not field_names
                        // so use the type name as the field name (matches the
                        // behavior of the ncdds.cc code).
                        nc_inq_compound_name(ncid, field_typeid, field_name);
                        NCStructure &ncs = dynamic_cast<NCStructure&>(*var(field_name));
                        ncs.do_structure_read(ncid, varid, field_typeid, values, has_values, field_offset + values_offset);
                    }
                    else if (var(field_name)->is_vector_type()) {
                        // Because the netcdf api reads data 'atomically' from
                        // compounds, this call works for both cardinal and
                        // array variables.
                        NCArray &child_array = dynamic_cast<NCArray&>(*var(field_name));
                        vector<size_t> cor(field_ndims);
                        vector<size_t> edg(field_ndims);
                        vector<ptrdiff_t> step(field_ndims);
                        bool has_stride;
                        long nels = child_array.format_constraint(cor.data(), step.data(), edg.data(), &has_stride);
                        child_array.do_array_read(ncid, varid, field_typeid,
                                values, has_values, field_offset + values_offset,
                                nels, cor.data(), edg.data(), step.data(), has_stride);
                    }
                    else if (var(field_name)->is_simple_type()) {
                        var(field_name)->val2buf(values.data()  + field_offset + values_offset);
                    }
                    else {
                        throw InternalErr(__FILE__, __LINE__, "Expecting a netcdf user defined type or an array or a scalar.");
                    }
 
                    var(field_name)->set_read_p(true);
                }
                break;
            }
 
            case NC_VLEN:
                cerr << "in build_user_defined; found a vlen." << endl;
                break;
            case NC_OPAQUE:
                cerr << "in build_user_defined; found a opaque." << endl;
                break;
            case NC_ENUM:
                cerr << "in build_user_defined; found a enum." << endl;
                break;
            default:
                throw InternalErr(__FILE__, __LINE__, "Expected one of NC_COMPOUND, NC_VLEN, NC_OPAQUE or NC_ENUM");
        }
    }
    else
        throw InternalErr(__FILE__, __LINE__, "Found a DAP Structure bound to a non-user-defined type in the netcdf file " + dataset());
#else
        throw InternalErr(__FILE__, __LINE__, "Found a DAP Structure bound to a non-user-defined type in the netcdf file " + dataset());
#endif
}
 
bool NCStructure::read()
{
    if (read_p()) // nothing to do
        return true;
 
    int ncid;
    int errstat = nc_open(dataset().c_str(), NC_NOWRITE, &ncid); /* netCDF id */
    if (errstat != NC_NOERR)
        throw Error(errstat, "Could not open the dataset's file (" + dataset() + ")");
 
    int varid; /* variable Id */
    errstat = nc_inq_varid(ncid, name().c_str(), &varid);
    if (errstat != NC_NOERR)
        throw InternalErr(__FILE__, __LINE__, "Could not get variable ID for: " + name() + ". (error: " + long_to_string(errstat) + ").");
 
    nc_type datatype; /* variable data type */
    errstat = nc_inq_vartype(ncid, varid, &datatype);
    if (errstat != NC_NOERR)
        throw Error(errstat, "Could not read data type information about : " + name() + ". (error: " + long_to_string(errstat) + ").");
 
    // For Compound types, netcdf's nc_get_var() reads all of the structure's
    // values in one shot, including values for nested structures. Pass the
    // (reference to the) space for these in at the start of what may be a
    // series of recursive calls.
    vector<char> values;
    do_structure_read(ncid, varid, datatype, values, false /*has_values*/, 0 /*values_offset*/);
 
    set_read_p(true);
 
    if (nc_close(ncid) != NC_NOERR)
        throw InternalErr(__FILE__, __LINE__, "Could not close the dataset!");
 
    return true;
}