Test_AttVectors.cpp

Test of netCDF C++ API: read attributes into vectors.

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

/*-----------------------------------------------------------------------------
    Produces the following NetCDF file:

    netcdf Test_AttVectors {
    // global attributes:
        :NcUbyte = 65UB, 66UB, 67UB ;
        :NcByte = 65b, 66b, 67b ;
        :NcChar = "ABC" ;
        :NcShort = 11s, 22s, 33s ;
        :NcUshort = 11US, 22US, 33US ;
        :NcInt = 11, 22, 33 ;
        :NcUint = 11U, 22U, 33U ;
        :NcFloat = 3.14159f, 0.31831f, 9.8696f ;
        :NcDouble = 3.1415901184082, 0.318309992551804, 9.86960029602051 ;
        :NcInt64 = 11L, 22L, 33L ;
        :NcUint64 = 11UL, 22UL, 33UL ;
        string :NcString = "Do", "whah", "ditty" ;
    }

-----------------------------------------------------------------------------*/

#include <iostream>
using std::cout;
using std::endl;

#include "netcdf4"
using namespace netcdf;
#include <memory>

//-----------------------------------------------------------------------------
// configuration
char const * const ncFileName = "Test_AttVectors.nc";

//-----------------------------------------------------------------------------
// attribute data

namespace {     // anonymous

  struct AttData
  {
    static short const size = 3;
    static char charData[size];
    static int intData[size];
    static float floatData[size];
    static char const * const strData[size];
  };

  char AttData::charData[size] = { 'A', 'B', 'C' };
  int AttData::intData[size] = { 11, 22, 33 };
  float AttData::floatData[size] = { 3.14159, 0.31831, 9.8696 };
  char const * const AttData::strData[size] = { "Do", "whah", "ditty" };

  struct AttVectors
  {
    static short const size = 12;
    TVecUbyte uBytes;           // NcUbyte
    TVecByte bytes;             // NcByte
    TVecChar chars;             // NcChar
    TVecShort shorts;           // NcShort
    TVecUshort ushorts;         // NcUshort
    TVecInt ints;               // NcInt
    TVecUint uints;             // NcUint
    TVecFloat floats;           // NcFloat
    TVecDouble doubles;         // NcDouble
    TVecInt64 int64s;           // NcInt64
    TVecUint64 uint64s;         // NcUint64
    TVecString strings;         // NcString
  };

  struct AttNames
  {
    typedef char const * const  CStr;
    static short const size = 12;
    static CStr
        uBytes, bytes, chars, shorts, ushorts, ints, uints,
        floats, doubles, int64s, uint64s, strings;
  };

  AttNames::CStr
        AttNames::uBytes        = "NcUbyte",
        AttNames::bytes         = "NcByte",
        AttNames::chars         = "NcChar",
        AttNames::shorts        = "NcShort",
        AttNames::ushorts       = "NcUshort",
        AttNames::ints          = "NcInt",
        AttNames::uints         = "NcUint",
        AttNames::floats        = "NcFloat",
        AttNames::doubles       = "NcDouble",
        AttNames::int64s        = "NcInt64",
        AttNames::uint64s       = "NcUint64",
        AttNames::strings       = "NcString";

} // namespace anonymous

//-----------------------------------------------------------------------------
std::auto_ptr<NcFile> CreateNcFile (
    std::string const & fileName )
{
    std::auto_ptr<NcFile> pNcFile (
        new NcFile ( fileName, NcFile::Replace, NcFile::NetCDF4 ) );
    pNcFile->ToDataMode();
    return pNcFile;
}

//-----------------------------------------------------------------------------
void AddAttributes ( NcFile & ncFile, std::vector<NcGroupAtt> & attVec )
{
    // NcGroupAtt PutAtt ( std::string const name, NcType const & type, size_t len, const T* dataValues )
    attVec.push_back( ncFile.PutAtt ( AttNames::uBytes,  ncUbyte,  AttData::size, AttData::charData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::bytes,   ncByte,   AttData::size, AttData::charData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::chars,   ncChar,   AttData::size, AttData::charData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::shorts,  ncShort,  AttData::size, AttData::intData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::ushorts, ncUshort, AttData::size, AttData::intData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::ints,    ncInt,    AttData::size, AttData::intData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::uints,   ncUint,   AttData::size, AttData::intData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::floats,  ncFloat,  AttData::size, AttData::floatData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::doubles, ncDouble, AttData::size, AttData::floatData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::int64s,  ncInt64,  AttData::size, AttData::intData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::uint64s, ncUint64, AttData::size, AttData::intData ) );
    attVec.push_back( ncFile.PutAtt ( AttNames::strings, ncString, AttData::size, AttData::strData ) );
}

//-----------------------------------------------------------------------------
void ReadAttributes ( NcFile & ncFile, std::vector<NcGroupAtt> const & attVec, AttVectors & vecData )
{
    attVec[0].Get ( vecData.uBytes );   // NcUbyte
    attVec[1].Get ( vecData.bytes );    // NcByte
    attVec[2].Get ( vecData.chars );    // NcChar
    attVec[3].Get ( vecData.shorts );   // NcShort
    attVec[4].Get ( vecData.ushorts );  // NcUshort
    attVec[5].Get ( vecData.ints );     // NcInt
    attVec[6].Get ( vecData.uints );    // NcUint
    attVec[7].Get ( vecData.floats );   // NcFloat
    attVec[8].Get ( vecData.doubles );  // NcDouble
    attVec[9].Get ( vecData.int64s );   // NcInt64
    attVec[10].Get ( vecData.uint64s ); // NcUint64
    attVec[11].Get ( vecData.strings ); // NcString
}

//-----------------------------------------------------------------------------
template
<
  class TLHS,   // non-container array
  class TRHS    // container of values to compare to
>
inline bool AllEqual ( TLHS const & lhs, TRHS const & rhs )
{
    return std::equal( lhs, lhs + rhs.size(), rhs.begin() );
}

void CompareData ( NcFile & ncFile, AttVectors const & vecData )
{
    std::string const yes = "passed";
    std::string const no  = "failed";
    cout << "Comparing input values to original values: " << endl;
    cout << AttNames::uBytes  << ":\t" << ( AllEqual( AttData::charData,  vecData.uBytes  ) ? yes : no ) << endl;
    cout << AttNames::bytes   << ":\t" << ( AllEqual( AttData::charData,  vecData.bytes   ) ? yes : no ) << endl;
    cout << AttNames::chars   << ":\t" << ( AllEqual( AttData::charData,  vecData.chars   ) ? yes : no ) << endl;
    cout << AttNames::shorts  << ":\t" << ( AllEqual( AttData::intData,   vecData.shorts  ) ? yes : no ) << endl;
    cout << AttNames::ushorts << ":\t" << ( AllEqual( AttData::intData,   vecData.ushorts ) ? yes : no ) << endl;
    cout << AttNames::ints    << ":\t" << ( AllEqual( AttData::intData,   vecData.ints    ) ? yes : no ) << endl;
    cout << AttNames::uints   << ":\t" << ( AllEqual( AttData::intData,   vecData.uints   ) ? yes : no ) << endl;
    cout << AttNames::floats  << ":\t" << ( AllEqual( AttData::floatData, vecData.floats  ) ? yes : no ) << endl;
    cout << AttNames::doubles << ":\t" << ( AllEqual( AttData::floatData, vecData.doubles ) ? yes : no ) << endl;
    cout << AttNames::int64s  << ":\t" << ( AllEqual( AttData::intData,   vecData.int64s  ) ? yes : no ) << endl;
    cout << AttNames::uint64s << ":\t" << ( AllEqual( AttData::intData,   vecData.uint64s ) ? yes : no ) << endl;
    cout << AttNames::strings << ":\t" << ( AllEqual( AttData::strData,   vecData.strings ) ? yes : no ) << endl;
}

//-----------------------------------------------------------------------------
int main ()
{
    cout << "Test of netCDF C++ API: read attributes into vectors" << endl;
    try
    {
        cout << "Creating file: " << ncFileName << endl;
        std::auto_ptr<NcFile> pNcFile = CreateNcFile (ncFileName);

        cout << "Add attributes to file..." << endl;
        std::vector<NcGroupAtt> attVec;
        AddAttributes( *pNcFile, attVec );

        cout << "Read attributes from file..." << endl;
        AttVectors vecData;
        ReadAttributes( *pNcFile, attVec, vecData );

        CompareData( *pNcFile, vecData );
    }
    catch (std::exception const & e)
    {
        cout << "Exception: " << e.what() << endl;
    }
    catch (...)
    {
        cout << "Error: unknown error." << endl;
    }
    cout << "\n   all done!" << endl;
    return 0;
}
//-----------------------------------------------------------------------------