utility_AMOS.hh

Go to the documentation of this file.

#ifndef __utility_AMOS_HH
#define __utility_AMOS_HH 1

#include "inttypes_AMOS.hh"
#include "exceptions_AMOS.hh"
#include <new>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <cassert>
#include <errno.h>

//-- Include hash_map
#ifdef __GNUC__
#if __GNUC__ < 3
  #include <hash_map.h>
  namespace Sgi { using ::hash_map; }; // inherit globals
  #define HASHMAP std
#else
  #include <ext/hash_map>
  #if __GNUC_MINOR__ == 0
    namespace Sgi = std;               // GCC 3.0
    #define HASHMAP std
  #else
    namespace Sgi = ::__gnu_cxx;       // GCC 3.1 and later
    #define HASHMAP __gnu_cxx
  #endif
#endif
#else      // ...  there are other compilers, right?
  namespace Sgi = std;
  #define HASHMAP std
#endif




namespace AMOS {

//--------------------------------------------------- SafeCalloc ---------------
inline void * SafeCalloc (size_t num, size_t size)
{
  void * Q = calloc (num, size);
  if ( Q == NULL )
    AMOS_THROW_ALLOC ("calloc failed");

  return Q;
}


//--------------------------------------------------- SafeMalloc ---------------
inline void * SafeMalloc (size_t size)
{
  void * Q = malloc (size);
  if ( Q == NULL )
    AMOS_THROW_ALLOC ("malloc failed");

  return Q;
}


//--------------------------------------------------- SafeRealloc --------------
inline void * SafeRealloc (void * P, size_t size)
{
  void * Q = realloc (P, size);
  if ( Q == NULL  &&  size != 0 )
    AMOS_THROW_ALLOC ("realloc failed");

  return Q;
}


//--------------------------------------------------- SafeStrdup ---------------
inline char * SafeStrdup (const char * str)
{
  char * Q = strdup (str);
  if ( Q == NULL )
    AMOS_THROW_ALLOC ("strdup failed");
  return Q;
}


//--------------------------------------------------- Complement ---------------
char Complement (char ch);


//--------------------------------------------------- ReverseComplement --------
void ReverseComplement (std::string & str);


//--------------------------------------------------- ReverseComplement --------
void ReverseComplement (char * str);


//--------------------------------------------------- Reverse ------------------
void Reverse (std::string & str);


//--------------------------------------------------- Reverse ------------------
void Reverse (char * str);


//------------------------------------------------- writeLE ------------------
inline void writeLE (std::ostream & out, const uint8_t * i)
{
  out . put ((char)(*i));
}
inline void writeLE (std::ostream & out, const int8_t * i)
{
  writeLE (out, (const uint8_t *)(i));
}
inline void writeLE (std::ostream & out, const BankFlags_t * i)
{
  assert ( sizeof (BankFlags_t) == 1 );
  writeLE (out, (const uint8_t *)(i));
}


//------------------------------------------------- writeLE ------------------
inline void writeLE (std::ostream & out, const uint16_t * i)
{
  union {uint16_t i; char c[sizeof (uint16_t)];} u16;
  u16.i = htol16 (*i);
  out . write (u16.c, sizeof (uint16_t));
}
inline void writeLE (std::ostream & out, const int16_t * i)
{
  writeLE (out, (const uint16_t *)(i));
}


//------------------------------------------------- writeLE ------------------
inline void writeLE (std::ostream & out, const uint32_t * i)
{
  union {uint32_t i; char c[sizeof (uint32_t)];} u32;
  u32.i = htol32 (*i);
  out . write (u32.c, sizeof (uint32_t));
}
inline void writeLE (std::ostream & out, const int32_t * i)
{
  writeLE (out, (const uint32_t *)(i));
}


//------------------------------------------------- writeLE ------------------
inline void writeLE (std::ostream & out, const uint64_t * i)
{
  union {uint64_t i; char c[sizeof (uint64_t)];} u64;
  u64.i = htol64 (*i);
  out . write (u64.c, sizeof (uint64_t));
}
inline void writeLE (std::ostream & out, const int64_t * i)
{
  writeLE (out, (const uint64_t *)(i));
}


//------------------------------------------------- readLE -------------------
inline void readLE (std::istream & in, uint8_t * i)
{
  *i = in . get( );
}
inline void readLE (std::istream & in, int8_t * i)
{
  readLE (in, (uint8_t *)(i));
}
inline void readLE (std::istream & in, BankFlags_t * i)
{
  assert ( sizeof (BankFlags_t) == 1 );
  readLE (in, (uint8_t *)(i));
}


//------------------------------------------------- readLE -------------------
inline void readLE (std::istream & in, uint16_t * i)
{
  union {uint16_t i; char c[sizeof (uint16_t)];} u16;
  in . read (u16.c, sizeof (uint16_t));
  *i = ltoh16 (u16.i);
}
inline void readLE (std::istream & in, int16_t * i)
{
  readLE (in, (uint16_t *)(i));
}


//------------------------------------------------- readLE -------------------
inline void readLE (std::istream & in, uint32_t * i)
{
  union {uint32_t i; char c[sizeof (uint32_t)];} u32;
  in . read (u32.c, sizeof (uint32_t));
  *i = ltoh32 (u32.i);
}
inline void readLE (std::istream & in, int32_t * i)
{
  readLE (in, (uint32_t *)(i));
}


//------------------------------------------------- readLE -------------------
inline void readLE (std::istream & in, uint64_t * i)
{
  union {uint64_t i; char c[sizeof (uint64_t)];} u64;
  in . read (u64.c, sizeof (uint64_t));
  *i = ltoh64 (u64.i);
}
inline void readLE (std::istream & in, int64_t * i)
{
  readLE (in, (uint64_t *)(i));
}

} // namespace AMOS

#endif // #ifndef __utility_AMOS_HH

---