inttypes_AMOS.hh

Go to the documentation of this file.

#ifndef __inttypes_AMOS_HH
#define __inttypes_AMOS_HH 1

#if HAVE_CONFIG_H
# include "config.h"
#endif

#include <inttypes.h>       
#include <limits.h>
#include <string>


namespace AMOS {

typedef uint32_t  ID_t;      
typedef uint32_t  NCode_t;   
typedef uint32_t  SD_t;      
typedef int32_t   Size_t;    
typedef Size_t    Pos_t;     
typedef char      Status_t;  

const uint8_t  NCODE_SIZE  =  3;         
const NCode_t  NULL_NCODE  =  0;         
const ID_t     NULL_ID     =  0;         
const Status_t NULL_STATUS =  0;         
const char     MIN_QUALITY = '0';        
const char     MAX_QUALITY = '0' + 63;   
const char     NULL_CHAR   = '\0';       
const char     NL_CHAR     = '\n';       
const std::string  NULL_STRING = &NULL_CHAR; 

const ID_t     MAX_ID      = ~((uint32_t)0);        
const Size_t   MAX_SIZE    = ~((uint32_t)0) >> 1;   
const Pos_t    MAX_POS     = ~((uint32_t)0) >> 1;   


//----------------------------------------------------- Qual2Char --------------
inline char Qual2Char (uint8_t qual)
{
  return qual + MIN_QUALITY;
}


//----------------------------------------------------- Char2Qual --------------
inline uint8_t Char2Qual (char qual)
{
  return qual - MIN_QUALITY;
}


//----------------------------------------------------- Decode -----------------
inline std::string Decode (NCode_t ncode)
{
  char buff[4] = {ncode & CHAR_MAX, ncode >> CHAR_BIT & CHAR_MAX,
                  ncode >> CHAR_BIT >> CHAR_BIT & CHAR_MAX, '\0'};
  return buff;
}


//----------------------------------------------------- Encode -----------------
inline NCode_t Encode (const std::string & str)
{
  return (((str[2] << CHAR_BIT) | str[1]) << CHAR_BIT) | str[0];
}


//================================================ BankFlags_t =================
//==============================================================================
struct BankFlags_t
{
//-- check which way we pack our bits, reverse order if machine is hi-to-lo
//   we should also limit this to 1byte in size to avoid endian issues
#ifdef BITFIELDS_HTOL
  uint8_t nibble      : 4;        
  uint8_t is_flagB    : 1;        
  uint8_t is_flagA    : 1;        
  uint8_t is_modified : 1;        
  uint8_t is_removed  : 1;        
#else
  uint8_t is_removed  : 1;        
  uint8_t is_modified : 1;        
  uint8_t is_flagA    : 1;        
  uint8_t is_flagB    : 1;        
  uint8_t nibble      : 4;        
#endif  

  //------------------------------------------------- BankFlags_t --------------
  BankFlags_t ( )
  {
    clear( );
  }
  
  
  //------------------------------------------------- ~BankFlags_t -------------
  ~BankFlags_t ( )
  {
    
  }


  //------------------------------------------------- clear --------------------
  void clear ( )
  {
    is_removed = is_modified = is_flagA = is_flagB = 0; nibble = 0;
  }
};


#define swap16(x) \
     ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8))


#define swap32(x) \
     ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8)    \
      | (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))


#define swap64(x) \
     ((((x) & 0xff00000000000000ull) >> 56)    \
      | (((x) & 0x00ff000000000000ull) >> 40)  \
      | (((x) & 0x0000ff0000000000ull) >> 24)  \
      | (((x) & 0x000000ff00000000ull) >> 8)   \
      | (((x) & 0x00000000ff000000ull) << 8)   \
      | (((x) & 0x0000000000ff0000ull) << 24)  \
      | (((x) & 0x000000000000ff00ull) << 40)  \
      | (((x) & 0x00000000000000ffull) << 56))



//-- check machine endian-ness, if host is big-endian we need to swap
#ifdef WORDS_BIGENDIAN
# define htol16(x)     swap16(x)    
# define htol32(x)     swap32(x)    
# define htol64(x)     swap64(x)    
# define ltoh16(x)     swap16(x)    
# define ltoh32(x)     swap32(x)    
# define ltoh64(x)     swap64(x)    
#else
# define htol16(x)     (x)          
# define htol32(x)     (x)          
# define htol64(x)     (x)          
# define ltoh16(x)     (x)          
# define ltoh32(x)     (x)          
# define ltoh64(x)     (x)          
#endif

//-- check machine endian-ness, if host is little-endian we need to swap
#ifdef WORDS_BIGENDIAN
# define htob16(x)     (x)          
# define htob32(x)     (x)          
# define htob64(x)     (x)          
# define btoh16(x)     (x)          
# define btoh32(x)     (x)          
# define btoh64(x)     (x)          
#else
# define htob16(x)     swap16(x)    
# define htob32(x)     swap32(x)    
# define htob64(x)     swap64(x)    
# define btoh16(x)     swap16(x)    
# define btoh32(x)     swap32(x)    
# define btoh64(x)     swap64(x)    
#endif

} // namespace AMOS

#endif // #ifndef __inttypes_AMOS_HH

---