FONcAttributes.cc

Go to the documentation of this file.

// FONcAttributes.cc

// This file is part of BES Netcdf File Out Module

// Copyright (c) 2004,2005 University Corporation for Atmospheric Research
// Author: Patrick West <pwest@ucar.edu> and Jose Garcia <jgarcia@ucar.edu>
//
// This library 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 library 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 University Corporation for Atmospheric Research at
// 3080 Center Green Drive, Boulder, CO 80301

// (c) COPYRIGHT University Corporation for Atmospheric Research 2004-2005
// Please read the full copyright statement in the file COPYRIGHT_UCAR.
//
// Authors:
//      pwest       Patrick West <pwest@ucar.edu>
//      jgarcia     Jose Garcia <jgarcia@ucar.edu>

#include <sstream>

using std::istringstream ;

#include <netcdf.h>

#include <BESDebug.h>
#include <BESInternalError.h>

#include "FONcAttributes.h"
#include "FONcUtils.h"

void
FONcAttributes::add_attributes( int ncid, int varid, BaseType *b )
{
    string emb_name ;
    BaseType *parent = b->get_parent() ;
    if( parent )
    {
        FONcAttributes::add_attributes( ncid, varid, parent, emb_name ) ;
    }
    addattrs( ncid, varid, b, "" ) ;
}

void
FONcAttributes::add_attributes( int ncid, int varid, BaseType *b,
                                string &emb_name )
{
    BaseType *parent = b->get_parent() ;
    if( parent )
    {
        FONcAttributes::add_attributes( ncid, varid, parent, emb_name ) ;
    }
    if( !emb_name.empty() )
    {
        emb_name += FONC_EMBEDDED_SEPARATOR ;
    }
    emb_name += b->name() ;
    addattrs( ncid, varid, b, emb_name ) ;
}

void
FONcAttributes::addattrs( int ncid, int varid, BaseType *b,
                          const string &var_name )
{
    AttrTable &attrs = b->get_attr_table() ;
    addattrs( ncid, varid, attrs, var_name, "" ) ;
}

void
FONcAttributes::addattrs( int ncid, int varid, AttrTable &attrs,
                          const string &var_name, const string &prepend_attr )
{
    unsigned int num_attrs = attrs.get_size() ;
    if( num_attrs )
    {
        AttrTable::Attr_iter i = attrs.attr_begin() ;
        AttrTable::Attr_iter e = attrs.attr_end() ;
        for( ; i != e; i++ )
        {
            unsigned int num_vals = attrs.get_attr_num( i ) ;
            if( num_vals )
            {
                addattrs( ncid, varid, var_name, attrs, i, prepend_attr ) ;
            }
        }
    }
}

void
FONcAttributes::addattrs( int ncid, int varid, const string &var_name,
                          AttrTable &attrs,
                          AttrTable::Attr_iter &attr,
                          const string &prepend_attr )
{
    string attr_name = attrs.get_name( attr ) ;
    string new_attr_name ;
    if( !prepend_attr.empty() )
    {
        new_attr_name = prepend_attr + FONC_EMBEDDED_SEPARATOR + attr_name ;
    }
    else
    {
        new_attr_name = attr_name ;
    }

    string new_name ;
    if( !var_name.empty() )
    {
        new_name = var_name + FONC_ATTRIBUTE_SEPARATOR + new_attr_name ;
    }
    else
    {
        new_name = new_attr_name ;
    }
    new_name = FONcUtils::id2netcdf( new_name ) ;
    if( varid == NC_GLOBAL )
        BESDEBUG( "fonc", "Adding global attributes " << new_name << endl ) ;
    else
        BESDEBUG( "fonc", "Adding attributes " << new_name << endl ) ;

    int stax = NC_NOERR ;
    unsigned int attri = 0 ;
    AttrType type = attrs.get_attr_type( attr ) ;
    unsigned int num_vals = attrs.get_attr_num( attr ) ;
    switch( type )
    {
        case Attr_container:
            {
                // flatten
                BESDEBUG( "fonc", "Attribute " << new_name
                                  << " is an attribute container" << endl ) ;
                AttrTable *container = attrs.get_attr_table( attr ) ;
                if( container )
                {
                    addattrs( ncid, varid, *container, var_name, new_attr_name ) ;
                }
            }
            break ;
        case Attr_byte:
            {
                // unsigned char
                unsigned char vals[num_vals] ;
                for( attri = 0; attri < num_vals; attri++ )
                {
                    string val = attrs.get_attr( attr, attri ) ;
                    istringstream is( val ) ;
                    unsigned int uival = 0 ;
                    is >> uival ;
                    vals[attri] = (unsigned char)uival ;
                }
                stax = nc_put_att_uchar( ncid, varid, new_name.c_str(),
                                         NC_BYTE, num_vals, vals ) ;
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write byte attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_int16:
            {
                // short
                short vals[num_vals] ;
                for( attri = 0; attri < num_vals; attri++ )
                {
                    string val = attrs.get_attr( attr, attri ) ;
                    istringstream is( val ) ;
                    short sval = 0 ;
                    is >> sval ;
                    vals[attri] = sval ;
                }
                stax = nc_put_att_short( ncid, varid, new_name.c_str(),
                                         NC_SHORT, num_vals, vals ) ;
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write short attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_uint16:
            {
                // unsigned short
                // (needs to be big enough to store an unsigned short
                int vals[num_vals] ;
                for( attri = 0; attri < num_vals; attri++ )
                {
                    string val = attrs.get_attr( attr, attri ) ;
                    istringstream is( val ) ;
                    int ival = 0 ;
                    is >> ival ;
                    vals[attri] = ival ;
                }
                stax = nc_put_att_int( ncid, varid, new_name.c_str(),
                                       NC_INT, num_vals, vals ) ;
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write unsinged short attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_int32:
            {
                // int
                int vals[num_vals] ;
                for( attri = 0; attri < num_vals; attri++ )
                {
                    string val = attrs.get_attr( attr, attri ) ;
                    istringstream is( val ) ;
                    int ival = 0 ;
                    is >> ival ;
                    vals[attri] = ival ;
                }
                stax = nc_put_att_int( ncid, varid, new_name.c_str(),
                                       NC_INT, num_vals, vals ) ;
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write int attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_uint32:
            {
                // uint
                // needs to be big enough to store an unsigned int
                int vals[num_vals] ;
                for( attri = 0; attri < num_vals; attri++ )
                {
                    string val = attrs.get_attr( attr, attri ) ;
                    istringstream is( val ) ;
                    int lval = 0 ;
                    is >> lval ;
                    vals[attri] = lval ;
                }
                stax = nc_put_att_int( ncid, varid, new_name.c_str(),
                                        NC_INT, num_vals, vals ) ;
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write byte attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_float32:
            {
                // float
                float vals[num_vals] ;
                for( attri = 0; attri < num_vals; attri++ )
                {
                    string val = attrs.get_attr( attr, attri ) ;
                    istringstream is( val ) ;
                    float fval = 0 ;
                    is >> fval ;
                    vals[attri] = fval ;
                }
                stax = nc_put_att_float( ncid, varid, new_name.c_str(),
                                         NC_FLOAT, num_vals, vals ) ;
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write float attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_float64:
            {
                // double
                double vals[num_vals] ;
                for( attri = 0; attri < num_vals; attri++ )
                {
                    string val = attrs.get_attr( attr, attri ) ;
                    istringstream is( val ) ;
                    double dval = 0 ;
                    is >> dval ;
                    vals[attri] = dval ;
                }
                stax = nc_put_att_double( ncid, varid, new_name.c_str(),
                                          NC_DOUBLE, num_vals, vals ) ;
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write double attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_string:
        case Attr_url:
        case Attr_other_xml:    // Added. jhrg 12.27.2011
            {
                // string
                string val = attrs.get_attr( attr, 0 ) ;
                for( attri = 1; attri < num_vals; attri++ )
                {
                    val += "\n" + attrs.get_attr( attr, attri ) ;
                }
                stax = nc_put_att_text( ncid, varid, new_name.c_str(),
                                        val.length(), val.c_str());
                if( stax != NC_NOERR )
                {
                    string err = (string)"File out netcdf, "
                                 + "failed to write string attribute "
                                 + new_name ;
                    FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
                }
            }
            break ;
        case Attr_unknown:
            {
                string err = (string)"File out netcdf, "
                             + "failed to write unknown type of attribute "
                             + new_name ;
                FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
            }
            break ;
    }
}

void
FONcAttributes::add_original_name( int ncid, int varid,
                                   const string &var_name,
                                   const string &orig )
{
    if( var_name != orig )
    {
        string attr_name = FONC_ORIGINAL_NAME ;
        int stax = nc_put_att_text( ncid, varid, attr_name.c_str(),
                                orig.length(), orig.c_str());
        if( stax != NC_NOERR )
        {
            string err = (string)"File out netcdf, "
                         + "failed to write change of name attribute for "
                         + var_name ;
            FONcUtils::handle_error( stax, err, __FILE__, __LINE__ ) ;
        }
    }
}