ncEnumType.h

#include <string>
#include "ncType.h"
#include "netcdf.h"
#include "ncCheck.h"
 
#ifndef NcEnumTypeClass
#define NcEnumTypeClass
 
 
namespace netCDF
{
  class NcGroup;  // forward declaration.
 
  class NcEnumType : public NcType
    {
    public:
      
      enum ncEnumType   {
    nc_BYTE     = NC_BYTE,  
    nc_SHORT    = NC_SHORT,     
    nc_INT      = NC_INT,   
    nc_UBYTE    = NC_UBYTE, 
    nc_USHORT   = NC_USHORT,    
    nc_UINT     = NC_UINT,  
    nc_INT64    = NC_INT64, 
    nc_UINT64   = NC_UINT64 
      };
      
      NcEnumType();
 
      NcEnumType(const NcGroup& grp, const std::string& name);
 
      NcEnumType(const NcType& ncType);
 
      NcEnumType& operator=(const NcEnumType& rhs);
      
      NcEnumType& operator=(const NcType& rhs);
      
      NcEnumType(const NcEnumType& rhs);
      
      ~NcEnumType(){}
      
      
      template <class T> void addMember(const std::string& name, T memberValue)
      {
    ncCheck(nc_insert_enum(groupId, myId, name.c_str(), (void*) &memberValue),__FILE__,__LINE__);
      }
 
      size_t  getMemberCount() const;
      
      std::string  getMemberNameFromIndex(int index) const;
 
      template <class T>  std::string  getMemberNameFromValue(const T memberValue) const {
    char charName[NC_MAX_NAME+1];
    ncCheck(nc_inq_enum_ident(groupId,myId,static_cast<long long>(memberValue),charName),__FILE__,__LINE__);
    return std::string(charName);
      }
    
      template <class T> void getMemberValue(int index, T& memberValue) const
    {
      char* charName=NULL;
      ncCheck(nc_inq_enum_member(groupId,myId,index,charName,&memberValue),__FILE__,__LINE__);
    }
 
      NcType  getBaseType() const;
      
  };
  
}
 
#endif