/* Hdf_common.cpp */

#include <cstdio>
#include <cstring>
#include "Hdf_common.hpp"

const char *Hdf_common::hdf_access_mode(const int32 mode) { // static buffer inside
  static char cstr_type[32];
  
  switch(mode) {
  case DFACC_READ : { strcpy(cstr_type, "r") ; break ; }
  case DFACC_WRITE : { strcpy(cstr_type, "rw"); break ; }
  case DFACC_CREATE : { strcpy(cstr_type, "c"); break ; }
  default : { std::strcpy(cstr_type, "unknown") ; break ; }
  }
  return cstr_type; 
}

const char *Hdf_common::hdf_cstr_type(const int32 data_type) { // static buffer inside
  static char cstr_type[32];
  
  switch(data_type) {
  case DFNT_CHAR8 : { strcpy(cstr_type, "char8") ; break ; }
  case DFNT_UCHAR8 : { strcpy(cstr_type, "uchar8"); break ; }
  case DFNT_INT8 : { strcpy(cstr_type, "int8"); break ; }
  case DFNT_UINT8 : { strcpy(cstr_type, "uint8"); break ; }
  case DFNT_INT16 : { strcpy(cstr_type, "int16"); break ; }
  case DFNT_UINT16 : { strcpy(cstr_type, "uint16"); break ; }
  case DFNT_INT32 : { strcpy(cstr_type, "int32"); break ; }
  case DFNT_UINT32 : { strcpy(cstr_type, "uint32"); break ; }
  case DFNT_FLOAT32 : { strcpy(cstr_type, "float32"); break ; }
  case DFNT_FLOAT64 : { strcpy(cstr_type, "float64"); break ; }
  default : { std::strcpy(cstr_type, "unknown") ; break ; }
  }
  return cstr_type; 
}

const int32 Hdf_common::hdf_int32_type(const char* data_type) {
  if ( strcmp(data_type,"char8") == 0 ) return DFNT_CHAR8;
  else if ( strcmp(data_type,"uchar8") == 0 ) return DFNT_UCHAR8;
  else if ( strcmp(data_type,"int8") == 0 ) return DFNT_INT8;
  else if ( strcmp(data_type,"uint8") == 0 ) return DFNT_UINT8;
  else if ( strcmp(data_type,"int16") == 0 ) return DFNT_INT16;
  else if ( strcmp(data_type,"uint16") == 0 ) return DFNT_UINT16;
  else if ( strcmp(data_type,"int32") == 0 ) return DFNT_INT32;
  else if ( strcmp(data_type,"uint32") == 0 ) return DFNT_UINT32;
  else if ( strcmp(data_type,"float32") == 0 ) return DFNT_FLOAT32;
  else if ( strcmp(data_type,"float64") == 0 ) return DFNT_FLOAT64;
  else return FAIL;
}

size_t Hdf_common::hdf_sizeof(const int32 data_type) {
  
  switch(data_type) {
  case DFNT_CHAR8 : { return sizeof(char8) ; break ; }
  case DFNT_UCHAR8 : { return sizeof(uchar8); break ; }
  case DFNT_INT8 : { return sizeof(int8); break ; }
  case DFNT_UINT8 : { return sizeof(uint8); break ; }
  case DFNT_INT16 : { return sizeof(int16); break ; }
  case DFNT_UINT16 : { return sizeof(uint16); break ; }
  case DFNT_INT32 : { return sizeof(int32); break ; }
  case DFNT_UINT32 : { return sizeof(uint32); break ; }
  case DFNT_FLOAT32 : { return sizeof(float32); break ; }
  case DFNT_FLOAT64 : { return sizeof(float64); break ; }
  default : { std::fprintf(stderr,"%s: %d: unknown hdf type code: %ld\n", __FILE__, __LINE__, data_type); abort(); /* should never arrive there */ ; break ; }
  }
}
size_t Hdf_common::hdf_sizeof(const char* data_type) {
  if ( strcmp(data_type,"char8") == 0 ) return sizeof(char8);
  else if ( strcmp(data_type,"uchar8") == 0 ) return sizeof(uchar8);
  else if ( strcmp(data_type,"int8") == 0 ) return sizeof(int8);
  else if ( strcmp(data_type,"uint8") == 0 ) return sizeof(uint8);
  else if ( strcmp(data_type,"int16") == 0 ) return sizeof(int16);
  else if ( strcmp(data_type,"uint16") == 0 ) return sizeof(uint16);
  else if ( strcmp(data_type,"int32") == 0 ) return sizeof(int32);
  else if ( strcmp(data_type,"uint32") == 0 ) return sizeof(uint32);
  else if ( strcmp(data_type,"float32") == 0 ) return sizeof(float32);
  else if ( strcmp(data_type,"float64") == 0 ) return sizeof(float64);
  else return 0;
}
std::string Hdf_common::hdf_type_info(const int32 data_type) {
    switch(data_type) {
    case DFNT_CHAR8 : {
            char8 v;
            return typeid(v).name() ;
            break ;
        }
    case DFNT_UCHAR8 : {
            uchar8 v;
            return typeid(v).name();
            break ;
        }
    case DFNT_INT8 : {
            int8 v;
            return typeid(v).name();
            break ;
        }
    case DFNT_UINT8 : {
            uint8 v;
            return typeid(v).name();
            break ;
        }
    case DFNT_INT16 : {
            int16 v;
            return typeid(v).name() ;
            break ;
        }
    case DFNT_UINT16 : {
            uint16 v;
            return typeid(v).name() ;
            break ;
        }
    case DFNT_INT32 : {
            int32 v;
            return typeid(v).name() ;
            break ;
        }
    case DFNT_UINT32 : {
            uint32 v;
            return typeid(v).name() ;
            break ;
        }
    case DFNT_FLOAT32 : {
            float32 v;
            return typeid(v).name() ;
            break ;
        }
    case DFNT_FLOAT64 : {
            float64 v;
            return typeid(v).name() ;
            break ;
        }
    default : {
            std::fprintf(stderr,"%s: %d: unknown hdf type code: %ld\n", __FILE__, __LINE__, data_type);
            abort(); // should never arrive there
            break ;
        }
    }
};

const char *hdf_format_string(const int32 data_type) { // static buffer inside
  static char format_type[16];

  switch(data_type) {
  case DFNT_CHAR8 : { strcpy(format_type, "%s") ; break ; }
  case DFNT_UCHAR8 : { strcpy(format_type, "%s"); break ; }
  case DFNT_INT8 : { strcpy(format_type, "%d"); break ; }
  case DFNT_UINT8 : { strcpy(format_type, "%u"); break ; }
  case DFNT_INT16 : { strcpy(format_type, "%hd"); break ; }
  case DFNT_UINT16 : { strcpy(format_type, "%hd"); break ; }
  case DFNT_INT32 : { strcpy(format_type, "%ld"); break ; }
  case DFNT_UINT32 : { strcpy(format_type, "%lu"); break ; }
  case DFNT_FLOAT32 : { strcpy(format_type, "%f"); break ; }
  case DFNT_FLOAT64 : { strcpy(format_type, "%lf"); break ; }
  default : {  fprintf(stderr,"%s: %d: unknown hdf type code: %ld\n", __FILE__, __LINE__, data_type); abort(); /* should never arrive there */ ; break ; }
  }

  return format_type;

}