src/api/BamConstants.h

   1 // ***************************************************************************
   2 // BamConstants.h (c) 2011 Derek Barnett
   3 // Marth Lab, Department of Biology, Boston College
   4 // ---------------------------------------------------------------------------
   5 // Last modified: 10 October 2011 (DB)
   6 // ---------------------------------------------------------------------------
   7 // Provides basic constants for handling BAM files.
   8 // ***************************************************************************
   9
  10 #ifndef BAM_CONSTANTS_H
  11 #define BAM_CONSTANTS_H
  12
  13 #include <api/api_global.h>
  14 #include <cassert>
  15 #include <string>
  16
  17 /*! \namespace BamTools::Constants
  18     \brief Provides basic constants for handling BAM files.
  19 */
  20
  21 namespace BamTools {
  22 namespace Constants {
  23
  24 const uint8_t BAM_SIZEOF_INT = 4;
  25
  26 // header magic number
  27 const char* const BAM_HEADER_MAGIC = "BAM\1";
  28 const uint8_t BAM_HEADER_MAGIC_LENGTH = 4;
  29
  30 // BAM alignment core size
  31 const uint8_t BAM_CORE_SIZE        = 32;
  32 const uint8_t BAM_CORE_BUFFER_SIZE = 8;
  33
  34 // BAM alignment flags
  35 const int BAM_ALIGNMENT_PAIRED              = 0x0001;
  36 const int BAM_ALIGNMENT_PROPER_PAIR         = 0x0002;
  37 const int BAM_ALIGNMENT_UNMAPPED            = 0x0004;
  38 const int BAM_ALIGNMENT_MATE_UNMAPPED       = 0x0008;
  39 const int BAM_ALIGNMENT_REVERSE_STRAND      = 0x0010;
  40 const int BAM_ALIGNMENT_MATE_REVERSE_STRAND = 0x0020;
  41 const int BAM_ALIGNMENT_READ_1              = 0x0040;
  42 const int BAM_ALIGNMENT_READ_2              = 0x0080;
  43 const int BAM_ALIGNMENT_SECONDARY           = 0x0100;
  44 const int BAM_ALIGNMENT_QC_FAILED           = 0x0200;
  45 const int BAM_ALIGNMENT_DUPLICATE           = 0x0400;
  46
  47 // CIGAR constants
  48 const char* const BAM_CIGAR_LOOKUP = "MIDNSHP=X";
  49 const uint8_t BAM_CIGAR_MATCH    = 0;
  50 const uint8_t BAM_CIGAR_INS      = 1;
  51 const uint8_t BAM_CIGAR_DEL      = 2;
  52 const uint8_t BAM_CIGAR_REFSKIP  = 3;
  53 const uint8_t BAM_CIGAR_SOFTCLIP = 4;
  54 const uint8_t BAM_CIGAR_HARDCLIP = 5;
  55 const uint8_t BAM_CIGAR_PAD      = 6;
  56 const uint8_t BAM_CIGAR_SEQMATCH = 7;
  57 const uint8_t BAM_CIGAR_MISMATCH = 8;
  58
  59 const char BAM_CIGAR_MATCH_CHAR    = 'M';
  60 const char BAM_CIGAR_INS_CHAR      = 'I';
  61 const char BAM_CIGAR_DEL_CHAR      = 'D';
  62 const char BAM_CIGAR_REFSKIP_CHAR  = 'N';
  63 const char BAM_CIGAR_SOFTCLIP_CHAR = 'S';
  64 const char BAM_CIGAR_HARDCLIP_CHAR = 'H';
  65 const char BAM_CIGAR_PAD_CHAR      = 'P';
  66 const char BAM_CIGAR_SEQMATCH_CHAR = '=';
  67 const char BAM_CIGAR_MISMATCH_CHAR = 'X';
  68
  69 const int BAM_CIGAR_SHIFT = 4;
  70 const int BAM_CIGAR_MASK  = ((1 << BAM_CIGAR_SHIFT) - 1);
  71
  72 // BAM tag types & sizes
  73 const char BAM_TAG_TYPE_ASCII  = 'A';
  74 const char BAM_TAG_TYPE_UINT8  = 'c';
  75 const char BAM_TAG_TYPE_INT8   = 'C';
  76 const char BAM_TAG_TYPE_UINT16 = 's';
  77 const char BAM_TAG_TYPE_INT16  = 'S';
  78 const char BAM_TAG_TYPE_UINT32 = 'i';
  79 const char BAM_TAG_TYPE_INT32  = 'I';
  80 const char BAM_TAG_TYPE_FLOAT  = 'f';
  81 const char BAM_TAG_TYPE_STRING = 'Z';
  82 const char BAM_TAG_TYPE_HEX    = 'H';
  83 const char BAM_TAG_TYPE_ARRAY  = 'B';
  84
  85 const uint8_t BAM_TAG_TAGSIZE        = 2;
  86 const uint8_t BAM_TAG_TYPESIZE       = 1;
  87 const uint8_t BAM_TAG_ARRAYBASE_SIZE = 8;
  88
  89 // DNA bases
  90 const char* const BAM_DNA_LOOKUP = "=ACMGRSVTWYHKDBN";
  91 const uint8_t BAM_BASECODE_EQUAL = 0;
  92 const uint8_t BAM_BASECODE_A     = 1;
  93 const uint8_t BAM_BASECODE_C     = 2;
  94 const uint8_t BAM_BASECODE_M     = 3;
  95 const uint8_t BAM_BASECODE_G     = 4;
  96 const uint8_t BAM_BASECODE_R     = 5;
  97 const uint8_t BAM_BASECODE_S     = 6;
  98 const uint8_t BAM_BASECODE_V     = 7;
  99 const uint8_t BAM_BASECODE_T     = 8;
 100 const uint8_t BAM_BASECODE_W     = 9;
 101 const uint8_t BAM_BASECODE_Y     = 10;
 102 const uint8_t BAM_BASECODE_H     = 11;
 103 const uint8_t BAM_BASECODE_K     = 12;
 104 const uint8_t BAM_BASECODE_D     = 13;
 105 const uint8_t BAM_BASECODE_B     = 14;
 106 const uint8_t BAM_BASECODE_N     = 15;
 107
 108 const char BAM_DNA_EQUAL = '=';
 109 const char BAM_DNA_A     = 'A';
 110 const char BAM_DNA_C     = 'C';
 111 const char BAM_DNA_M     = 'M';
 112 const char BAM_DNA_G     = 'G';
 113 const char BAM_DNA_R     = 'R';
 114 const char BAM_DNA_S     = 'S';
 115 const char BAM_DNA_V     = 'V';
 116 const char BAM_DNA_T     = 'T';
 117 const char BAM_DNA_W     = 'W';
 118 const char BAM_DNA_Y     = 'Y';
 119 const char BAM_DNA_H     = 'H';
 120 const char BAM_DNA_K     = 'K';
 121 const char BAM_DNA_D     = 'D';
 122 const char BAM_DNA_B     = 'B';
 123 const char BAM_DNA_N     = 'N';
 124 const char BAM_DNA_DEL   = '-';
 125 const char BAM_DNA_PAD   = '*';
 126
 127 // zlib & BGZF constants
 128 const char GZIP_ID1   = 31;
 129 const char GZIP_ID2   = 139;
 130 const char CM_DEFLATE = 8;
 131 const char FLG_FEXTRA = 4;
 132 const char OS_UNKNOWN = 255;
 133 const char BGZF_XLEN  = 6;
 134 const char BGZF_ID1   = 66;
 135 const char BGZF_ID2   = 67;
 136 const char BGZF_LEN   = 2;
 137
 138 const int8_t   GZIP_WINDOW_BITS          = -15;
 139 const int8_t   Z_DEFAULT_MEM_LEVEL       = 8;
 140 const uint8_t  BGZF_BLOCK_HEADER_LENGTH  = 18;
 141 const uint8_t  BGZF_BLOCK_FOOTER_LENGTH  = 8;
 142 const uint32_t BGZF_MAX_BLOCK_SIZE       = 65536;
 143 const uint32_t BGZF_DEFAULT_BLOCK_SIZE   = 65536;
 144
 145 } // namespace Constants
 146
 147 //! \cond
 148 // -------------------------
 149 // tag-type helper structs
 150 // -------------------------
 151
 152 // fail on any types not specified below
 153 template<typename T>
 154 struct TagTypeHelper {
 155     static bool CanConvertFrom(const char) { assert(false); return false; }
 156     static bool CanConvertTo(const char) { assert(false); return false; }
 157     static char TypeCode(void) { assert(false); return 0; }
 158 };
 159
 160 template<>
 161 struct TagTypeHelper<uint8_t> {
 162     static bool CanConvertFrom(const char c) {
 163         return ( c == Constants::BAM_TAG_TYPE_ASCII ||
 164                  c == Constants::BAM_TAG_TYPE_UINT8 );
 165     }
 166     static bool CanConvertTo(const char c) {
 167         return ( c == Constants::BAM_TAG_TYPE_ASCII  ||
 168                  c == Constants::BAM_TAG_TYPE_UINT8  ||
 169                  c == Constants::BAM_TAG_TYPE_UINT16 ||
 170                  c == Constants::BAM_TAG_TYPE_UINT32 );
 171     }
 172
 173     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_UINT8; }
 174 };
 175
 176 template<>
 177 struct TagTypeHelper<int8_t> {
 178     static bool CanConvertFrom(const char c) {
 179         return ( c == Constants::BAM_TAG_TYPE_ASCII ||
 180                  c == Constants::BAM_TAG_TYPE_INT8 );
 181     }
 182     static bool CanConvertTo(const char c) {
 183         return ( c == Constants::BAM_TAG_TYPE_ASCII ||
 184                  c == Constants::BAM_TAG_TYPE_INT8  ||
 185                  c == Constants::BAM_TAG_TYPE_INT16 ||
 186                  c == Constants::BAM_TAG_TYPE_INT32 );
 187     }
 188     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_INT8; }
 189 };
 190
 191 template<>
 192 struct TagTypeHelper<uint16_t> {
 193     static bool CanCovnertFrom(const char c) {
 194         return ( c == Constants::BAM_TAG_TYPE_ASCII ||
 195                  c == Constants::BAM_TAG_TYPE_UINT8 ||
 196                  c == Constants::BAM_TAG_TYPE_UINT16 );
 197     }
 198     static bool CanConvertTo(const char c) {
 199         return ( c == Constants::BAM_TAG_TYPE_UINT16 ||
 200                  c == Constants::BAM_TAG_TYPE_UINT32);
 201     }
 202     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_UINT16; }
 203 };
 204
 205 template<>
 206 struct TagTypeHelper<int16_t> {
 207     static bool CanConvertFrom(const char c) {
 208         return ( c == Constants::BAM_TAG_TYPE_ASCII ||
 209                  c == Constants::BAM_TAG_TYPE_INT8 ||
 210                  c == Constants::BAM_TAG_TYPE_INT16 );
 211     }
 212     static bool CanConvertTo(const char c) {
 213         return ( c == Constants::BAM_TAG_TYPE_INT16 ||
 214                  c == Constants::BAM_TAG_TYPE_INT32);
 215     }
 216     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_INT16; }
 217 };
 218
 219 template<>
 220 struct TagTypeHelper<uint32_t> {
 221     static bool CanConvertFrom(const char c) {
 222         return ( c == Constants::BAM_TAG_TYPE_ASCII  ||
 223                  c == Constants::BAM_TAG_TYPE_UINT8  ||
 224                  c == Constants::BAM_TAG_TYPE_UINT16 ||
 225                  c == Constants::BAM_TAG_TYPE_UINT32 );
 226     }
 227     static bool CanConvertTo(const char c) {
 228         return ( c == Constants::BAM_TAG_TYPE_UINT32 );
 229     }
 230     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_UINT32; }
 231 };
 232
 233 template<>
 234 struct TagTypeHelper<int32_t> {
 235     static bool CanConvertFrom(const char c) {
 236         return ( c == Constants::BAM_TAG_TYPE_ASCII  ||
 237                  c == Constants::BAM_TAG_TYPE_INT8  ||
 238                  c == Constants::BAM_TAG_TYPE_INT16 ||
 239                  c == Constants::BAM_TAG_TYPE_INT32 );
 240     }
 241     static bool CanConvertTo(const char c) {
 242         return ( c == Constants::BAM_TAG_TYPE_INT32 );
 243     }
 244     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_INT32; }
 245 };
 246
 247 template<>
 248 struct TagTypeHelper<float> {
 249     static bool CanConvertFrom(const char c) {
 250         return ( c == Constants::BAM_TAG_TYPE_ASCII  ||
 251                  c == Constants::BAM_TAG_TYPE_UINT8  ||
 252                  c == Constants::BAM_TAG_TYPE_INT8   ||
 253                  c == Constants::BAM_TAG_TYPE_UINT16 ||
 254                  c == Constants::BAM_TAG_TYPE_INT16  ||
 255                  c == Constants::BAM_TAG_TYPE_UINT32 ||
 256                  c == Constants::BAM_TAG_TYPE_INT32  ||
 257                  c == Constants::BAM_TAG_TYPE_FLOAT);
 258     }
 259     static bool CanConvertTo(const char c) {
 260         return ( c == Constants::BAM_TAG_TYPE_FLOAT );
 261     }
 262     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_FLOAT; }
 263 };
 264
 265 template<>
 266 struct TagTypeHelper<std::string> {
 267     static bool CanConvertFrom(const char c) {
 268         return ( c == Constants::BAM_TAG_TYPE_HEX ||
 269                  c == Constants::BAM_TAG_TYPE_STRING );
 270     }
 271     static bool CanConvertTo(const char c) {
 272         return ( c == Constants::BAM_TAG_TYPE_HEX ||
 273                  c == Constants::BAM_TAG_TYPE_STRING );
 274     }
 275     static char TypeCode(void) { return Constants::BAM_TAG_TYPE_STRING; }
 276 };
 277
 278 //! \endcond
 279
 280 } // namespace BamTools
 281
 282 #endif // BAM_CONSTANTS_H