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