FONcUtils.cc

Go to the documentation of this file.

// FONcUtils.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 "config.h"
#include "FONcUtils.h"
#include "FONcByte.h"
#include "FONcStr.h"
#include "FONcShort.h"
#include "FONcInt.h"
#include "FONcFloat.h"
#include "FONcDouble.h"
#include "FONcStructure.h"
#include "FONcGrid.h"
#include "FONcArray.h"
#include "FONcSequence.h"

#include <BESInternalError.h>

string FONcUtils::name_prefix = "" ;

void
FONcUtils::reset()
{
    FONcArray::Dimensions.clear() ;
    FONcGrid::Maps.clear() ;
    FONcDim::DimNameNum = 0 ;
}

string
FONcUtils::id2netcdf( string in )
{
    // string of allowed characters in netcdf naming convention
    string allowed = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+_.@" ;
    // string of allowed first characters in netcdf naming
    // convention
    string first = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_" ;

    string::size_type i = 0;

    while( (i = in.find_first_not_of( allowed, i ) ) != string::npos)
    {
        in.replace( i, 1, "_" ) ;
        i++ ;
    }

    if( first.find( in[0] ) == string::npos )
    {
        in = FONcUtils::name_prefix + in ;
    }

    return in;
}

nc_type
FONcUtils::get_nc_type( BaseType *element )
{
    nc_type x_type = NC_NAT ; // the constant ncdf uses to define simple type

    string var_type = element->type_name() ;
    if( var_type == "Byte" )            // check this for dods type
        x_type = NC_SHORT ;
    else if( var_type == "String" )
        x_type = NC_CHAR ;
    else if( var_type == "Int16" )
        x_type = NC_SHORT ;
    // The attribute of UInt16 maps to NC_INT, so we need to map UInt16
    // to NC_INT for the variable so that end_def won't complain about
    // the inconsistent datatype between fillvalue and the variable. KY 2012-10-25
    //else if( var_type == "UInt16" )
    //  x_type = NC_SHORT ;
    else if( var_type == "UInt16" )
        x_type = NC_INT ;
    else if( var_type == "Int32" )
        x_type = NC_INT ;
    else if( var_type == "UInt32" )
        x_type = NC_INT ;
    else if( var_type == "Float32" )
        x_type = NC_FLOAT ;
    else if( var_type == "Float64" )
        x_type = NC_DOUBLE ;

    return x_type ;
}

string
FONcUtils::gen_name( const vector<string> &embed, const string &name,
                     string &original )
{
    string new_name ;
    vector<string>::const_iterator i = embed.begin() ;
    vector<string>::const_iterator e = embed.end() ;
    bool first = true ;
    for( ; i != e; i++ )
    {
        if( first ) new_name = (*i) ;
        else new_name += FONC_EMBEDDED_SEPARATOR + (*i) ;
        first = false ;
    }
    if( first ) new_name = name ;
    else new_name += FONC_EMBEDDED_SEPARATOR + name ;

    original = new_name ;

    return FONcUtils::id2netcdf( new_name ) ;
}

FONcBaseType *
FONcUtils::convert( BaseType *v )
{
    FONcBaseType *b = 0 ;
    switch( v->type() )
    {
        case dods_str_c:
        case dods_url_c:
            b = new FONcStr( v ) ;
            break ;
        case dods_byte_c:
            b = new FONcByte( v ) ;
            break ;
        case dods_int16_c:
        case dods_uint16_c:
            b = new FONcShort( v ) ;
            break ;
        case dods_int32_c:
        case dods_uint32_c:
            b = new FONcInt( v ) ;
            break ;
        case dods_float32_c:
            b = new FONcFloat( v ) ;
            break ;
        case dods_float64_c:
            b = new FONcDouble( v ) ;
            break ;
        case dods_grid_c:
            b = new FONcGrid( v ) ;
            break ;
        case dods_array_c:
            b = new FONcArray( v ) ;
            break ;
        case dods_structure_c:
            b = new FONcStructure( v ) ;
            break ;
        case dods_sequence_c:
            b = new FONcSequence( v ) ;
            break ;
        default:
            string err = (string)"file out netcdf, unable to "
                         + "write unknown variable type" ;
            throw BESInternalError( err, __FILE__, __LINE__ ) ;

    }
    return b ;
}

void
FONcUtils::handle_error( int stax, string &err, const string &file, int line )
{
    if( stax != NC_NOERR )
    {
        const char *nerr = nc_strerror( stax ) ;
        if( nerr )
        {
            err += (string)": " + nerr ;
        }
        else
        {
            err += (string)": unknown error" ;
        }
        throw BESInternalError( err, file, line ) ;
    }
}