X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=src%2Fapi%2FBamAlignment.cpp;h=162e1958b38802c8984eadf636726ef6efaf479f;hb=8c80d760637f8df39262683cd2570f0589423d36;hp=3dbc7e9d82f79b4c0c1bce37962a5c06ac5634d0;hpb=049d6b2501ea9c9afeb8588013d5f536246a2ca8;p=bamtools.git diff --git a/src/api/BamAlignment.cpp b/src/api/BamAlignment.cpp index 3dbc7e9..162e195 100644 --- a/src/api/BamAlignment.cpp +++ b/src/api/BamAlignment.cpp @@ -3,11 +3,15 @@ // Marth Lab, Department of Biology, Boston College // All rights reserved. // --------------------------------------------------------------------------- -// Last modified: 18 September 2010 (DB) +// Last modified: 21 March 2011 (DB) // --------------------------------------------------------------------------- // Provides the BamAlignment data structure // *************************************************************************** +#include +#include +using namespace BamTools; + #include #include #include @@ -15,11 +19,191 @@ #include #include #include -#include "BamAlignment.h" -using namespace BamTools; +using namespace std; + +// internal utility methods +namespace BamTools { +namespace Internal { + +/*! \fn bool IsValidSize(const string& tag, const string& type) + \internal + + Checks that tag name & type strings are expected sizes. + \a tag should have length + \a type should have length 1 + + \param tag BAM tag name + \param type BAM tag type-code + + \return \c true if both \a tag and \a type are correct sizes +*/ +bool IsValidSize(const string& tag, const string& type) { + return (tag.size() == Constants::BAM_TAG_TAGSIZE) && + (type.size() == Constants::BAM_TAG_TYPESIZE); +} + +/*! \fn bool SkipToNextTag(const char storageType, char* &pTagData, unsigned int& numBytesParsed) + \internal + + Moves to next available tag in tag data string -// default ctor -BamAlignment::BamAlignment(void) + \param storageType BAM tag type-code that determines how far to move cursor + \param pTagData pointer to current position (cursor) in tag string + \param numBytesParsed report of how many bytes were parsed (cumulatively) + + \return \c if storageType was a recognized BAM tag type + \post \a pTagData will point to the byte where the next tag data begins. + \a numBytesParsed will correspond to the cursor's position in the full TagData string. +*/ +bool SkipToNextTag(const char storageType, char* &pTagData, unsigned int& numBytesParsed) { + + switch (storageType) { + + case (Constants::BAM_TAG_TYPE_ASCII) : + case (Constants::BAM_TAG_TYPE_INT8) : + case (Constants::BAM_TAG_TYPE_UINT8) : + ++numBytesParsed; + ++pTagData; + break; + + case (Constants::BAM_TAG_TYPE_INT16) : + case (Constants::BAM_TAG_TYPE_UINT16) : + numBytesParsed += 2; + pTagData += 2; + break; + + case (Constants::BAM_TAG_TYPE_FLOAT) : + case (Constants::BAM_TAG_TYPE_INT32) : + case (Constants::BAM_TAG_TYPE_UINT32) : + numBytesParsed += 4; + pTagData += 4; + break; + + case (Constants::BAM_TAG_TYPE_STRING) : + case (Constants::BAM_TAG_TYPE_HEX) : + while(*pTagData) { + ++numBytesParsed; + ++pTagData; + } + // increment for null-terminator + ++numBytesParsed; + ++pTagData; + break; + + default: + // error case + fprintf(stderr, "BamAlignment ERROR: unknown tag type encountered: [%c]\n", storageType); + return false; + } + + // return success + return true; +} + +/*! \fn bool FindTag(const std::string& tag, char* &pTagData, const unsigned int& tagDataLength, unsigned int& numBytesParsed) + \internal + + Searches for requested tag in BAM tag data. + + \param tag requested 2-character tag name + \param pTagData pointer to current position in BamAlignment::TagData + \param tagDataLength length of BamAlignment::TagData + \param numBytesParsed number of bytes parsed so far + + \return \c true if found + + \post If \a tag is found, \a pTagData will point to the byte where the tag data begins. + \a numBytesParsed will correspond to the position in the full TagData string. + +*/ +bool FindTag(const std::string& tag, + char* &pTagData, + const unsigned int& tagDataLength, + unsigned int& numBytesParsed) +{ + + while ( numBytesParsed < tagDataLength ) { + + const char* pTagType = pTagData; + const char* pTagStorageType = pTagData + 2; + pTagData += 3; + numBytesParsed += 3; + + // check the current tag, return true on match + if ( strncmp(pTagType, tag.c_str(), 2) == 0 ) + return true; + + // get the storage class and find the next tag + if ( *pTagStorageType == '\0' ) return false; + if ( !SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) return false; + if ( *pTagData == '\0' ) return false; + } + + // checked all tags, none match + return false; +} + +} // namespace Internal +} // namespace BamTools + +/*! \class BamTools::BamAlignment + \brief The main BAM alignment data structure. + + Provides methods to query/modify BAM alignment data fields. +*/ +/*! \var BamAlignment::Name + \brief read name +*/ +/*! \var BamAlignment::Length + \brief length of query sequence +*/ +/*! \var BamAlignment::QueryBases + \brief 'original' sequence (as reported from sequencing machine) +*/ +/*! \var BamAlignment::AlignedBases + \brief 'aligned' sequence (includes any indels, padding, clipping) +*/ +/*! \var BamAlignment::Qualities + \brief FASTQ qualities (ASCII characters, not numeric values) +*/ +/*! \var BamAlignment::TagData + \brief tag data (use the provided methods to query/modify) +*/ +/*! \var BamAlignment::RefID + \brief ID number for reference sequence +*/ +/*! \var BamAlignment::Position + \brief position (0-based) where alignment starts +*/ +/*! \var BamAlignment::Bin + \brief BAM (standard) index bin number for this alignment +*/ +/*! \var BamAlignment::MapQuality + \brief mapping quality score +*/ +/*! \var BamAlignment::AlignmentFlag + \brief alignment bit-flag (use the provided methods to query/modify) +*/ +/*! \var BamAlignment::CigarData + \brief CIGAR operations for this alignment +*/ +/*! \var BamAlignment::MateRefID + \brief ID number for reference sequence where alignment's mate was aligned +*/ +/*! \var BamAlignment::MatePosition + \brief position (0-based) where alignment's mate starts +*/ +/*! \var BamAlignment::InsertSize + \brief mate-pair insert size +*/ +/*! \var BamAlignment::Filename + \brief name of BAM file which this alignment comes from +*/ + +/*! \fn BamAlignment::BamAlignment(void) + \brief constructor +*/ +BamAlignment::BamAlignment(void) : RefID(-1) , Position(-1) , MateRefID(-1) @@ -27,7 +211,9 @@ BamAlignment::BamAlignment(void) , InsertSize(0) { } -// copy ctor +/*! \fn BamAlignment::BamAlignment(const BamAlignment& other) + \brief copy constructor +*/ BamAlignment::BamAlignment(const BamAlignment& other) : Name(other.Name) , Length(other.Length) @@ -44,67 +230,39 @@ BamAlignment::BamAlignment(const BamAlignment& other) , MateRefID(other.MateRefID) , MatePosition(other.MatePosition) , InsertSize(other.InsertSize) + , Filename(other.Filename) , SupportData(other.SupportData) { } -// dtor +/*! \fn BamAlignment::~BamAlignment(void) + \brief destructor +*/ BamAlignment::~BamAlignment(void) { } -// Queries against alignment flags -bool BamAlignment::IsDuplicate(void) const { return ( (AlignmentFlag & DUPLICATE) != 0 ); } -bool BamAlignment::IsFailedQC(void) const { return ( (AlignmentFlag & QC_FAILED) != 0 ); } -bool BamAlignment::IsFirstMate(void) const { return ( (AlignmentFlag & READ_1) != 0 ); } -bool BamAlignment::IsMapped(void) const { return ( (AlignmentFlag & UNMAPPED) == 0 ); } -bool BamAlignment::IsMateMapped(void) const { return ( (AlignmentFlag & MATE_UNMAPPED) == 0 ); } -bool BamAlignment::IsMateReverseStrand(void) const { return ( (AlignmentFlag & MATE_REVERSE) != 0 ); } -bool BamAlignment::IsPaired(void) const { return ( (AlignmentFlag & PAIRED) != 0 ); } -bool BamAlignment::IsPrimaryAlignment(void) const { return ( (AlignmentFlag & SECONDARY) == 0 ); } -bool BamAlignment::IsProperPair(void) const { return ( (AlignmentFlag & PROPER_PAIR) != 0 ); } -bool BamAlignment::IsReverseStrand(void) const { return ( (AlignmentFlag & REVERSE) != 0 ); } -bool BamAlignment::IsSecondMate(void) const { return ( (AlignmentFlag & READ_2) != 0 ); } - -// Manipulate alignment flags -void BamAlignment::SetIsDuplicate(bool ok) { if (ok) AlignmentFlag |= DUPLICATE; else AlignmentFlag &= ~DUPLICATE; } -void BamAlignment::SetIsFailedQC(bool ok) { if (ok) AlignmentFlag |= QC_FAILED; else AlignmentFlag &= ~QC_FAILED; } -void BamAlignment::SetIsFirstMate(bool ok) { if (ok) AlignmentFlag |= READ_1; else AlignmentFlag &= ~READ_1; } -void BamAlignment::SetIsMateUnmapped(bool ok) { if (ok) AlignmentFlag |= MATE_UNMAPPED; else AlignmentFlag &= ~MATE_UNMAPPED; } -void BamAlignment::SetIsMateReverseStrand(bool ok) { if (ok) AlignmentFlag |= MATE_REVERSE; else AlignmentFlag &= ~MATE_REVERSE; } -void BamAlignment::SetIsPaired(bool ok) { if (ok) AlignmentFlag |= PAIRED; else AlignmentFlag &= ~PAIRED; } -void BamAlignment::SetIsProperPair(bool ok) { if (ok) AlignmentFlag |= PROPER_PAIR; else AlignmentFlag &= ~PROPER_PAIR; } -void BamAlignment::SetIsReverseStrand(bool ok) { if (ok) AlignmentFlag |= REVERSE; else AlignmentFlag &= ~REVERSE; } -void BamAlignment::SetIsSecondaryAlignment(bool ok) { if (ok) AlignmentFlag |= SECONDARY; else AlignmentFlag &= ~SECONDARY; } -void BamAlignment::SetIsSecondMate(bool ok) { if (ok) AlignmentFlag |= READ_2; else AlignmentFlag &= ~READ_2; } -void BamAlignment::SetIsUnmapped(bool ok) { if (ok) AlignmentFlag |= UNMAPPED; else AlignmentFlag &= ~UNMAPPED; } - -// calculates alignment end position, based on starting position and CIGAR operations -int BamAlignment::GetEndPosition(bool usePadded, bool zeroBased) const { +/*! \fn bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const std::string& value) + \brief Adds a field with string data to the BAM tags. - // initialize alignment end to starting position - int alignEnd = Position; + Does NOT modify an existing tag - use \link BamAlignment::EditTag() \endlink instead. - // iterate over cigar operations - std::vector::const_iterator cigarIter = CigarData.begin(); - std::vector::const_iterator cigarEnd = CigarData.end(); - for ( ; cigarIter != cigarEnd; ++cigarIter) { - const char cigarType = (*cigarIter).Type; - if ( cigarType == 'M' || cigarType == 'D' || cigarType == 'N' ) - alignEnd += (*cigarIter).Length; - else if ( usePadded && cigarType == 'I' ) - alignEnd += (*cigarIter).Length; - } - - // adjust for zeroBased, if necessary - if (zeroBased) - return alignEnd - 1; - else - return alignEnd; -} + \param tag 2-character tag name + \param type 1-character tag type (must be "Z" or "H") + \param value string data to store + + \return \c true if the \b new tag was added successfully + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const std::string& value) { + // skip if core data not parsed if ( SupportData.HasCoreOnly ) return false; - if ( tag.size() != 2 || type.size() != 1 ) return false; - if ( type != "Z" && type != "H" ) return false; + + // validate tag/type size & that type is OK for string value + if ( !Internal::IsValidSize(tag, type) ) return false; + if ( type.at(0) != Constants::BAM_TAG_TYPE_STRING && + type.at(0) != Constants::BAM_TAG_TYPE_HEX ) + return false; // localize the tag data char* pTagData = (char*)TagData.data(); @@ -113,10 +271,11 @@ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const // if tag already exists, return false // use EditTag explicitly instead - if ( FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) return false; + if ( Internal::FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) + return false; // otherwise, copy tag data to temp buffer - std::string newTag = tag + type + value; + string newTag = tag + type + value; const int newTagDataLength = tagDataLength + newTag.size() + 1; // leave room for null-term char originalTagData[newTagDataLength]; memcpy(originalTagData, TagData.c_str(), tagDataLength + 1); // '+1' for TagData null-term @@ -132,11 +291,30 @@ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const return true; } +/*! \fn bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const uint32_t& value) + \brief Adds a field with unsigned integer data to the BAM tags. + + Does NOT modify an existing tag - use \link BamAlignment::EditTag() \endlink instead. + + \param tag 2-character tag name + \param type 1-character tag type (must NOT be "f", "Z", or "H") + \param value unsigned int data to store + + \return \c true if the \b new tag was added successfully + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const uint32_t& value) { + // skip if core data not parsed if ( SupportData.HasCoreOnly ) return false; - if ( tag.size() != 2 || type.size() != 1 ) return false; - if ( type == "f" || type == "Z" || type == "H" ) return false; + + // validate tag/type size & that type is OK for uint32_t value + if ( !Internal::IsValidSize(tag, type) ) return false; + if ( type.at(0) == Constants::BAM_TAG_TYPE_FLOAT || + type.at(0) == Constants::BAM_TAG_TYPE_STRING || + type.at(0) == Constants::BAM_TAG_TYPE_HEX ) + return false; // localize the tag data char* pTagData = (char*)TagData.data(); @@ -145,21 +323,22 @@ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const // if tag already exists, return false // use EditTag explicitly instead - if ( FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) return false; + if ( Internal::FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) + return false; // otherwise, convert value to string - union { unsigned int value; char valueBuffer[sizeof(unsigned int)]; } un; + union { uint32_t value; char valueBuffer[sizeof(uint32_t)]; } un; un.value = value; // copy original tag data to temp buffer - std::string newTag = tag + type; + string newTag = tag + type; const int newTagDataLength = tagDataLength + newTag.size() + 4; // leave room for new integer char originalTagData[newTagDataLength]; memcpy(originalTagData, TagData.c_str(), tagDataLength + 1); // '+1' for TagData null-term // append newTag strcat(originalTagData + tagDataLength, newTag.data()); - memcpy(originalTagData + tagDataLength + newTag.size(), un.valueBuffer, sizeof(unsigned int)); + memcpy(originalTagData + tagDataLength + newTag.size(), un.valueBuffer, sizeof(uint32_t)); // store temp buffer back in TagData const char* newTagData = (const char*)originalTagData; @@ -169,16 +348,49 @@ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const return true; } +/*! \fn bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const int32_t& value) + \brief Adds a field with signed integer data to the BAM tags. + + Does NOT modify an existing tag - use \link BamAlignment::EditTag() \endlink instead. + + \param tag 2-character tag name + \param type 1-character tag type (must NOT be "f", "Z", or "H") + \param value signed int data to store + + \return \c true if the \b new tag was added successfully + + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const int32_t& value) { return AddTag(tag, type, (const uint32_t&)value); } +/*! \fn bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const float& value) + \brief Adds a field with floating-point data to the BAM tags. + + Does NOT modify an existing tag - use \link BamAlignment::EditTag() \endlink instead. + + \param tag 2-character tag name + \param type 1-character tag type (must NOT be "Z" or "H") + \param value float data to store + + \return \c true if the \b new tag was added successfully + + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const float& value) { + // skip if core data not parsed if ( SupportData.HasCoreOnly ) return false; - if ( tag.size() != 2 || type.size() != 1 ) return false; - if ( type == "Z" || type == "H" ) return false; - + + // validate tag/type size & that type is OK for float value + if ( !Internal::IsValidSize(tag, type) ) return false; + if ( type.at(0) == Constants::BAM_TAG_TYPE_STRING || + type.at(0) == Constants::BAM_TAG_TYPE_HEX ) + return false; + // localize the tag data char* pTagData = (char*)TagData.data(); const unsigned int tagDataLength = TagData.size(); @@ -186,14 +398,15 @@ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const // if tag already exists, return false // use EditTag explicitly instead - if ( FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) return false; + if ( Internal::FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) + return false; // otherwise, convert value to string union { float value; char valueBuffer[sizeof(float)]; } un; un.value = value; // copy original tag data to temp buffer - std::string newTag = tag + type; + string newTag = tag + type; const int newTagDataLength = tagDataLength + newTag.size() + 4; // leave room for new float char originalTagData[newTagDataLength]; memcpy(originalTagData, TagData.c_str(), tagDataLength + 1); // '+1' for TagData null-term @@ -210,11 +423,211 @@ bool BamAlignment::AddTag(const std::string& tag, const std::string& type, const return true; } +/*! \fn bool BamAlignment::BuildCharData(void) + \brief Populates alignment string fields (read name, bases, qualities, tag data). + + An alignment retrieved using BamReader::GetNextAlignmentCore() lacks this data. + Using that method makes parsing much quicker when only positional data is required. + + However, if you later want to access the character data fields from such an alignment, + use this method to populate those fields. Provides ability to do 'lazy evaluation' of + alignment parsing. + + \return \c true if character data populated successfully (or was already available to begin with) +*/ +bool BamAlignment::BuildCharData(void) { + + // skip if char data already parsed + if ( !SupportData.HasCoreOnly ) + return true; + + // check system endianness + bool IsBigEndian = BamTools::SystemIsBigEndian(); + + // calculate character lengths/offsets + const unsigned int dataLength = SupportData.BlockLength - Constants::BAM_CORE_SIZE; + const unsigned int seqDataOffset = SupportData.QueryNameLength + (SupportData.NumCigarOperations * 4); + const unsigned int qualDataOffset = seqDataOffset + (SupportData.QuerySequenceLength+1)/2; + const unsigned int tagDataOffset = qualDataOffset + SupportData.QuerySequenceLength; + const unsigned int tagDataLength = dataLength - tagDataOffset; + + // check offsets to see what char data exists + const bool hasSeqData = ( seqDataOffset < dataLength ); + const bool hasQualData = ( qualDataOffset < dataLength ); + const bool hasTagData = ( tagDataOffset < dataLength ); + + // set up char buffers + const char* allCharData = SupportData.AllCharData.data(); + const char* seqData = ( hasSeqData ? (((const char*)allCharData) + seqDataOffset) : (const char*)0 ); + const char* qualData = ( hasQualData ? (((const char*)allCharData) + qualDataOffset) : (const char*)0 ); + char* tagData = ( hasTagData ? (((char*)allCharData) + tagDataOffset) : (char*)0 ); + + // store alignment name (relies on null char in name as terminator) + Name.assign((const char*)(allCharData)); + + // save query sequence + QueryBases.clear(); + if ( hasSeqData ) { + QueryBases.reserve(SupportData.QuerySequenceLength); + for (unsigned int i = 0; i < SupportData.QuerySequenceLength; ++i) { + char singleBase = Constants::BAM_DNA_LOOKUP[ ( (seqData[(i/2)] >> (4*(1-(i%2)))) & 0xf ) ]; + QueryBases.append(1, singleBase); + } + } + + // save qualities, converting from numeric QV to 'FASTQ-style' ASCII character + Qualities.clear(); + if ( hasQualData ) { + Qualities.reserve(SupportData.QuerySequenceLength); + for (unsigned int i = 0; i < SupportData.QuerySequenceLength; ++i) { + char singleQuality = (char)(qualData[i]+33); + Qualities.append(1, singleQuality); + } + } + + // clear previous AlignedBases + AlignedBases.clear(); + + // if QueryBases has data, build AlignedBases using CIGAR data + // otherwise, AlignedBases will remain empty (this case IS allowed) + if ( !QueryBases.empty() ) { + + // resize AlignedBases + AlignedBases.reserve(SupportData.QuerySequenceLength); + + // iterate over CigarOps + int k = 0; + vector::const_iterator cigarIter = CigarData.begin(); + vector::const_iterator cigarEnd = CigarData.end(); + for ( ; cigarIter != cigarEnd; ++cigarIter ) { + const CigarOp& op = (*cigarIter); + + switch (op.Type) { + + // for 'M', 'I' - write bases + case (Constants::BAM_CIGAR_MATCH_CHAR) : + case (Constants::BAM_CIGAR_INS_CHAR) : + AlignedBases.append(QueryBases.substr(k, op.Length)); + // fall through + + // for 'S' - soft clip, do not write bases + // but increment placeholder 'k' + case (Constants::BAM_CIGAR_SOFTCLIP_CHAR) : + k += op.Length; + break; + + // for 'D' - write gap character + case (Constants::BAM_CIGAR_DEL_CHAR) : + AlignedBases.append(op.Length, Constants::BAM_DNA_DEL); + break; + + // for 'P' - write padding character + case (Constants::BAM_CIGAR_PAD_CHAR) : + AlignedBases.append( op.Length, Constants::BAM_DNA_PAD ); + break; + + // for 'N' - write N's, skip bases in original query sequence + case (Constants::BAM_CIGAR_REFSKIP_CHAR) : + AlignedBases.append( op.Length, Constants::BAM_DNA_N ); + break; + + // for 'H' - hard clip, do nothing to AlignedBases, move to next op + case (Constants::BAM_CIGAR_HARDCLIP_CHAR) : + break; + + // shouldn't get here + default: + fprintf(stderr, "BamAlignment ERROR: invalid CIGAR operation type: %c\n", op.Type); + exit(1); + } + } + } + + // save tag data + TagData.clear(); + if ( hasTagData ) { + if ( IsBigEndian ) { + int i = 0; + while ( (unsigned int)i < tagDataLength ) { + + i += Constants::BAM_TAG_TAGSIZE; // skip tag chars (e.g. "RG", "NM", etc.) + const char type = tagData[i]; // get tag type at position i + ++i; // move i past tag type + + switch (type) { + + case(Constants::BAM_TAG_TYPE_ASCII) : + case(Constants::BAM_TAG_TYPE_INT8) : + case(Constants::BAM_TAG_TYPE_UINT8) : + ++i; + break; + + case(Constants::BAM_TAG_TYPE_INT16) : + case(Constants::BAM_TAG_TYPE_UINT16) : + BamTools::SwapEndian_16p(&tagData[i]); + i += sizeof(uint16_t); + break; + + case(Constants::BAM_TAG_TYPE_FLOAT) : + case(Constants::BAM_TAG_TYPE_INT32) : + case(Constants::BAM_TAG_TYPE_UINT32) : + BamTools::SwapEndian_32p(&tagData[i]); + i += sizeof(uint32_t); + break; + + case(Constants::BAM_TAG_TYPE_HEX) : + case(Constants::BAM_TAG_TYPE_STRING) : + // no endian swapping necessary for hex-string/string data + while (tagData[i]) { ++i; } + // increment one more for null terminator + ++i; + break; + + // shouldn't get here + default : + fprintf(stderr, "BamAlignment ERROR: invalid tag value type: %c\n", type); + exit(1); + } + } + } + + // store tagData in alignment + TagData.resize(tagDataLength); + memcpy((char*)TagData.data(), tagData, tagDataLength); + } + + // clear the core-only flag + SupportData.HasCoreOnly = false; + + // return success + return true; +} + +/*! \fn bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const std::string& value) + \brief Edits a BAM tag field containing string data. + + If \a tag does not exist, a new entry is created. + + \param tag 2-character tag name + \param type 1-character tag type (must be "Z" or "H") + \param value string data to store + + \return \c true if the tag was modified/created successfully + + \sa BamAlignment::RemoveTag() + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const std::string& value) { + // skip if core data not parsed if ( SupportData.HasCoreOnly ) return false; - if ( tag.size() != 2 || type.size() != 1 ) return false; - if ( type != "Z" && type != "H" ) return false; + + // validate tag/type size & that type is OK for string value + if ( !Internal::IsValidSize(tag, type) ) return false; + if ( type.at(0) != Constants::BAM_TAG_TYPE_STRING && + type.at(0) != Constants::BAM_TAG_TYPE_HEX ) + return false; // localize the tag data char* pOriginalTagData = (char*)TagData.data(); @@ -225,7 +638,7 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons unsigned int numBytesParsed = 0; // if tag found, store data in readGroup, return success - if ( FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { + if ( Internal::FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { // make sure array is more than big enough char newTagData[originalTagDataLength + value.size()]; @@ -241,7 +654,8 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons // skip to next tag (if tag for removal is last, return true) const char* pTagStorageType = pTagData - 1; - if ( !SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) return true; + if ( !Internal::SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) + return true; // copy everything from current tag (the next one after tag for removal) to end const unsigned int skippedDataLength = (numBytesParsed - beginningTagDataLength); @@ -261,13 +675,34 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons else return AddTag(tag, type, value); } +/*! \fn bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const uint32_t& value) + \brief Edits a BAM tag field containing unsigned integer data. + + If \a tag does not exist, a new entry is created. + + \param tag 2-character tag name + \param type 1-character tag type (must NOT be "f", "Z", or "H") + \param value unsigned integer data to store + + \return \c true if the tag was modified/created successfully + + \sa BamAlignment::RemoveTag() + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const uint32_t& value) { + // skip if core data not parsed if ( SupportData.HasCoreOnly ) return false; - if ( tag.size() != 2 || type.size() != 1 ) return false; - if ( type == "f" || type == "Z" || type == "H" ) return false; - - // localize the tag data + + // validate tag/type size & that type is OK for uint32_t value + if ( !Internal::IsValidSize(tag, type) ) return false; + if ( type.at(0) == Constants::BAM_TAG_TYPE_FLOAT || + type.at(0) == Constants::BAM_TAG_TYPE_STRING || + type.at(0) == Constants::BAM_TAG_TYPE_HEX ) + return false; + + // localize the tag data char* pOriginalTagData = (char*)TagData.data(); char* pTagData = pOriginalTagData; const unsigned int originalTagDataLength = TagData.size(); @@ -276,7 +711,7 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons unsigned int numBytesParsed = 0; // if tag found, store data in readGroup, return success - if ( FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { + if ( Internal::FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { // make sure array is more than big enough char newTagData[originalTagDataLength + sizeof(value)]; @@ -287,17 +722,18 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons memcpy(newTagData, pOriginalTagData, numBytesParsed); // copy new VALUE in place of current tag data - union { unsigned int value; char valueBuffer[sizeof(unsigned int)]; } un; + union { uint32_t value; char valueBuffer[sizeof(uint32_t)]; } un; un.value = value; - memcpy(newTagData + beginningTagDataLength, un.valueBuffer, sizeof(unsigned int)); + memcpy(newTagData + beginningTagDataLength, un.valueBuffer, sizeof(uint32_t)); // skip to next tag (if tag for removal is last, return true) const char* pTagStorageType = pTagData - 1; - if ( !SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) return true; + if ( !Internal::SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) + return true; // copy everything from current tag (the next one after tag for removal) to end const unsigned int skippedDataLength = (numBytesParsed - beginningTagDataLength); - const unsigned int endTagOffset = beginningTagDataLength + sizeof(unsigned int); + const unsigned int endTagOffset = beginningTagDataLength + sizeof(uint32_t); const unsigned int endTagDataLength = originalTagDataLength - beginningTagDataLength - skippedDataLength; memcpy(newTagData + endTagOffset, pTagData, endTagDataLength); @@ -313,16 +749,51 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons else return AddTag(tag, type, value); } +/*! \fn bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const int32_t& value) + \brief Edits a BAM tag field containing signed integer data. + + If \a tag does not exist, a new entry is created. + + \param tag 2-character tag name + \param type 1-character tag type (must NOT be "f", "Z", or "H") + \param value signed integer data to store + + \return \c true if the tag was modified/created successfully + + \sa BamAlignment::RemoveTag() + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const int32_t& value) { return EditTag(tag, type, (const uint32_t&)value); } +/*! \fn bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const float& value) + \brief Edits a BAM tag field containing floating-point data. + + If \a tag does not exist, a new entry is created. + + \param tag 2-character tag name + \param type 1-character tag type (must NOT be "Z" or "H") + \param value float data to store + + \return \c true if the tag was modified/created successfully + + \sa BamAlignment::RemoveTag() + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, const float& value) { + // skip if core data not parsed if ( SupportData.HasCoreOnly ) return false; - if ( tag.size() != 2 || type.size() != 1 ) return false; - if ( type == "Z" || type == "H" ) return false; - + + // validate tag/type size & that type is OK for float value + if ( !Internal::IsValidSize(tag, type) ) return false; + if ( type.at(0) == Constants::BAM_TAG_TYPE_STRING || + type.at(0) == Constants::BAM_TAG_TYPE_HEX ) + return false; + // localize the tag data char* pOriginalTagData = (char*)TagData.data(); char* pTagData = pOriginalTagData; @@ -332,7 +803,7 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons unsigned int numBytesParsed = 0; // if tag found, store data in readGroup, return success - if ( FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { + if ( Internal::FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { // make sure array is more than big enough char newTagData[originalTagDataLength + sizeof(value)]; @@ -349,7 +820,8 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons // skip to next tag (if tag for removal is last, return true) const char* pTagStorageType = pTagData - 1; - if ( !SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) return true; + if ( !Internal::SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) + return true; // copy everything from current tag (the next one after tag for removal) to end const unsigned int skippedDataLength = (numBytesParsed - beginningTagDataLength); @@ -369,18 +841,83 @@ bool BamAlignment::EditTag(const std::string& tag, const std::string& type, cons else return AddTag(tag, type, value); } -// get "NM" tag data - originally contributed by Aaron Quinlan -// stores data in 'editDistance', returns success/fail -bool BamAlignment::GetEditDistance(uint32_t& editDistance) const { +/*! \fn bool BamAlignment::GetEditDistance(uint32_t& editDistance) const + \brief Retrieves value of edit distance tag ("NM"). + + \deprecated Instead use BamAlignment::GetTag() + \code + BamAlignment::GetTag("NM", editDistance); + \endcode + + \param editDistance destination for retrieved value + + \return \c true if found +*/ +bool BamAlignment::GetEditDistance(uint32_t& editDistance) const { return GetTag("NM", (uint32_t&)editDistance); } -// get "RG" tag data -// stores data in 'readGroup', returns success/fail +/*! \fn int BamAlignment::GetEndPosition(bool usePadded = false, bool zeroBased = true) const + \brief Calculates alignment end position, based on starting position and CIGAR data. + + \param usePadded Inserted bases affect reported position. Default is false, so that reported + position stays 'sync-ed' with reference coordinates. + \param zeroBased Return (BAM standard) 0-based coordinate. Setting this to false can be useful + when using BAM data with half-open formats (e.g. BED). + + \return alignment end position +*/ +int BamAlignment::GetEndPosition(bool usePadded, bool zeroBased) const { + + // initialize alignment end to starting position + int alignEnd = Position; + + // iterate over cigar operations + vector::const_iterator cigarIter = CigarData.begin(); + vector::const_iterator cigarEnd = CigarData.end(); + for ( ; cigarIter != cigarEnd; ++cigarIter) { + const char cigarType = (*cigarIter).Type; + const uint32_t& cigarLength = (*cigarIter).Length; + + if ( cigarType == Constants::BAM_CIGAR_MATCH_CHAR || + cigarType == Constants::BAM_CIGAR_DEL_CHAR || + cigarType == Constants::BAM_CIGAR_REFSKIP_CHAR ) + alignEnd += cigarLength; + else if ( usePadded && cigarType == Constants::BAM_CIGAR_INS_CHAR ) + alignEnd += cigarLength; + } + + // adjust for zero-based coordinates, if requested + if ( zeroBased ) alignEnd -= 1; + + // return result + return alignEnd; +} + +/*! \fn bool BamAlignment::GetReadGroup(std::string& readGroup) const + \brief Retrieves value of read group tag ("RG"). + + \deprecated Instead use BamAlignment::GetTag() + \code + BamAlignment::GetTag("RG", readGroup); + \endcode + + \param readGroup destination for retrieved value + + \return \c true if found +*/ bool BamAlignment::GetReadGroup(std::string& readGroup) const { return GetTag("RG", readGroup); } +/*! \fn bool BamAlignment::GetTag(const std::string& tag, std::string& destination) const + \brief Retrieves the string value associated with a BAM tag. + + \param tag 2-character tag name + \param destination destination for retrieved value + + \return \c true if found +*/ bool BamAlignment::GetTag(const std::string& tag, std::string& destination) const { // make sure tag data exists @@ -393,7 +930,7 @@ bool BamAlignment::GetTag(const std::string& tag, std::string& destination) cons unsigned int numBytesParsed = 0; // if tag found, store data in readGroup, return success - if ( FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) { + if ( Internal::FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) { const unsigned int dataLength = strlen(pTagData); destination.clear(); destination.resize(dataLength); @@ -405,6 +942,14 @@ bool BamAlignment::GetTag(const std::string& tag, std::string& destination) cons return false; } +/*! \fn bool BamAlignment::GetTag(const std::string& tag, uint32_t& destination) const + \brief Retrieves the unsigned integer value associated with a BAM tag. + + \param tag 2-character tag name + \param destination destination for retrieved value + + \return \c true if found +*/ bool BamAlignment::GetTag(const std::string& tag, uint32_t& destination) const { // make sure tag data exists @@ -417,41 +962,42 @@ bool BamAlignment::GetTag(const std::string& tag, uint32_t& destination) const { unsigned int numBytesParsed = 0; // if tag found, determine data byte-length, store data in readGroup, return success - if ( FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) { + if ( Internal::FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) { // determine data byte-length const char type = *(pTagData - 1); int destinationLength = 0; switch (type) { + // 1 byte data - case 'A': - case 'c': - case 'C': + case (Constants::BAM_TAG_TYPE_ASCII) : + case (Constants::BAM_TAG_TYPE_INT8) : + case (Constants::BAM_TAG_TYPE_UINT8) : destinationLength = 1; break; // 2 byte data - case 's': - case 'S': + case (Constants::BAM_TAG_TYPE_INT16) : + case (Constants::BAM_TAG_TYPE_UINT16) : destinationLength = 2; break; // 4 byte data - case 'i': - case 'I': + case (Constants::BAM_TAG_TYPE_INT32) : + case (Constants::BAM_TAG_TYPE_UINT32) : destinationLength = 4; break; // unsupported type for integer destination (float or var-length strings) - case 'f': - case 'Z': - case 'H': - fprintf(stderr, "ERROR: Cannot store tag of type %c in integer destination\n", type); + case (Constants::BAM_TAG_TYPE_FLOAT) : + case (Constants::BAM_TAG_TYPE_STRING) : + case (Constants::BAM_TAG_TYPE_HEX) : + fprintf(stderr, "BamAlignment ERROR: cannot store tag of type %c in integer destination\n", type); return false; // unknown tag type default: - fprintf(stderr, "ERROR: Unknown tag storage class encountered: [%c]\n", type); + fprintf(stderr, "BamAlignment ERROR: unknown tag type encountered: [%c]\n", type); return false; } @@ -465,10 +1011,26 @@ bool BamAlignment::GetTag(const std::string& tag, uint32_t& destination) const { return false; } +/*! \fn bool BamAlignment::GetTag(const std::string& tag, int32_t& destination) const + \brief Retrieves the signed integer value associated with a BAM tag. + + \param tag 2-character tag name + \param destination destination for retrieved value + + \return \c true if found +*/ bool BamAlignment::GetTag(const std::string& tag, int32_t& destination) const { return GetTag(tag, (uint32_t&)destination); } +/*! \fn bool BamAlignment::GetTag(const std::string& tag, float& destination) const + \brief Retrieves the floating-point value associated with a BAM tag. + + \param tag 2-character tag name + \param destination destination for retrieved value + + \return \c true if found +*/ bool BamAlignment::GetTag(const std::string& tag, float& destination) const { // make sure tag data exists @@ -481,43 +1043,42 @@ bool BamAlignment::GetTag(const std::string& tag, float& destination) const { unsigned int numBytesParsed = 0; // if tag found, determine data byte-length, store data in readGroup, return success - if ( FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) { - //pTagData += numBytesParsed; + if ( Internal::FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) { // determine data byte-length const char type = *(pTagData - 1); int destinationLength = 0; - switch(type) { + switch (type) { // 1 byte data - case 'A': - case 'c': - case 'C': + case (Constants::BAM_TAG_TYPE_ASCII) : + case (Constants::BAM_TAG_TYPE_INT8) : + case (Constants::BAM_TAG_TYPE_UINT8) : destinationLength = 1; break; // 2 byte data - case 's': - case 'S': + case (Constants::BAM_TAG_TYPE_INT16) : + case (Constants::BAM_TAG_TYPE_UINT16) : destinationLength = 2; break; // 4 byte data - case 'f': - case 'i': - case 'I': + case (Constants::BAM_TAG_TYPE_FLOAT) : + case (Constants::BAM_TAG_TYPE_INT32) : + case (Constants::BAM_TAG_TYPE_UINT32) : destinationLength = 4; break; // unsupported type (var-length strings) - case 'Z': - case 'H': - fprintf(stderr, "ERROR: Cannot store tag of type %c in integer destination\n", type); + case (Constants::BAM_TAG_TYPE_STRING) : + case (Constants::BAM_TAG_TYPE_HEX) : + fprintf(stderr, "BamAlignment ERROR: cannot store tag of type %c in float destination\n", type); return false; // unknown tag type default: - fprintf(stderr, "ERROR: Unknown tag storage class encountered: [%c]\n", type); + fprintf(stderr, "BamAlignment ERROR: unknown tag type encountered: [%c]\n", type); return false; } @@ -531,11 +1092,147 @@ bool BamAlignment::GetTag(const std::string& tag, float& destination) const { return false; } +/*! \fn bool BamAlignment::GetTagType(const std::string& tag, char& type) const + \brief Retrieves the BAM tag type-code associated with requested tag name. + + \param tag 2-character tag name + \param type destination for the retrieved (1-character) tag type + + \return \c true if found + + \sa http://samtools.sourceforge.net/SAM-1.3.pdf + for more details on reserved tag names, supported tag types, etc. +*/ +bool BamAlignment::GetTagType(const std::string& tag, char& type) const { + + // make sure tag data exists + if ( SupportData.HasCoreOnly || TagData.empty() ) + return false; + + // localize the tag data + char* pTagData = (char*)TagData.data(); + const unsigned int tagDataLength = TagData.size(); + unsigned int numBytesParsed = 0; + + // lookup tag + if ( Internal::FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) { + + // retrieve tag type code + type = *(pTagData - 1); + + // validate that type is a proper BAM tag type + switch (type) { + case (Constants::BAM_TAG_TYPE_ASCII) : + case (Constants::BAM_TAG_TYPE_INT8) : + case (Constants::BAM_TAG_TYPE_UINT8) : + case (Constants::BAM_TAG_TYPE_INT16) : + case (Constants::BAM_TAG_TYPE_UINT16) : + case (Constants::BAM_TAG_TYPE_INT32) : + case (Constants::BAM_TAG_TYPE_UINT32) : + case (Constants::BAM_TAG_TYPE_FLOAT) : + case (Constants::BAM_TAG_TYPE_STRING) : + case (Constants::BAM_TAG_TYPE_HEX) : + return true; + + // unknown tag type + default: + fprintf(stderr, "BamAlignment ERROR: unknown tag type encountered: [%c]\n", type); + return false; + } + } + + // tag not found, return failure + return false; +} + +/*! \fn bool BamAlignment::IsDuplicate(void) const + \return \c true if this read is a PCR duplicate +*/ +bool BamAlignment::IsDuplicate(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_DUPLICATE) != 0 ); +} + +/*! \fn bool BamAlignment::IsFailedQC(void) const + \return \c true if this read failed quality control +*/ +bool BamAlignment::IsFailedQC(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_QC_FAILED) != 0 ); +} + +/*! \fn bool BamAlignment::IsFirstMate(void) const + \return \c true if alignment is first mate on paired-end read +*/ +bool BamAlignment::IsFirstMate(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_READ_1) != 0 ); +} + +/*! \fn bool BamAlignment::IsMapped(void) const + \return \c true if alignment is mapped +*/ +bool BamAlignment::IsMapped(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_UNMAPPED) == 0 ); +} + +/*! \fn bool BamAlignment::IsMateMapped(void) const + \return \c true if alignment's mate is mapped +*/ +bool BamAlignment::IsMateMapped(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_MATE_UNMAPPED) == 0 ); +} + +/*! \fn bool BamAlignment::IsMateReverseStrand(void) const + \return \c true if alignment's mate mapped to reverse strand +*/ +bool BamAlignment::IsMateReverseStrand(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_MATE_REVERSE_STRAND) != 0 ); +} + +/*! \fn bool BamAlignment::IsPaired(void) const + \return \c true if alignment part of paired-end read +*/ +bool BamAlignment::IsPaired(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_PAIRED) != 0 ); +} + +/*! \fn bool BamAlignment::IsPrimaryAlignment(void) const + \return \c true if reported position is primary alignment +*/ +bool BamAlignment::IsPrimaryAlignment(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_SECONDARY) == 0 ); +} + +/*! \fn bool BamAlignment::IsProperPair(void) const + \return \c true if alignment is part of read that satisfied paired-end resolution +*/ +bool BamAlignment::IsProperPair(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_PROPER_PAIR) != 0 ); +} + +/*! \fn bool BamAlignment::IsReverseStrand(void) const + \return \c true if alignment mapped to reverse strand +*/ +bool BamAlignment::IsReverseStrand(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_REVERSE_STRAND) != 0 ); +} + +/*! \fn bool BamAlignment::IsSecondMate(void) const + \return \c true if alignment is second mate on read +*/ +bool BamAlignment::IsSecondMate(void) const { + return ( (AlignmentFlag & Constants::BAM_ALIGNMENT_READ_2) != 0 ); +} + +/*! \fn bool BamAlignment::RemoveTag(const std::string& tag) + \brief Removes field from BAM tags. + + \return \c true if tag was removed successfully (or didn't exist before) +*/ bool BamAlignment::RemoveTag(const std::string& tag) { // BamAlignments fetched using BamReader::GetNextAlignmentCore() are not allowed // also, return false if no data present to remove - if ( SupportData.HasCoreOnly || TagData.empty() ) return false; + if ( SupportData.HasCoreOnly || TagData.empty() ) + return false; // localize the tag data char* pOriginalTagData = (char*)TagData.data(); @@ -545,12 +1242,12 @@ bool BamAlignment::RemoveTag(const std::string& tag) { unsigned int numBytesParsed = 0; // if tag found, store data in readGroup, return success - if ( FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { + if ( Internal::FindTag(tag, pTagData, originalTagDataLength, numBytesParsed) ) { char newTagData[originalTagDataLength]; // copy original tag data up til desired tag - pTagData -= 3; + pTagData -= 3; numBytesParsed -= 3; const unsigned int beginningTagDataLength = numBytesParsed; newTagDataLength += beginningTagDataLength; @@ -560,7 +1257,8 @@ bool BamAlignment::RemoveTag(const std::string& tag) { const char* pTagStorageType = pTagData + 2; pTagData += 3; numBytesParsed += 3; - if ( !SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) return true; + if ( !Internal::SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) + return true; // copy everything from current tag (the next one after tag for removal) to end const unsigned int skippedDataLength = (numBytesParsed - beginningTagDataLength); @@ -576,70 +1274,117 @@ bool BamAlignment::RemoveTag(const std::string& tag) { return false; } -bool BamAlignment::FindTag(const std::string& tag, char* &pTagData, const unsigned int& tagDataLength, unsigned int& numBytesParsed) { +/*! \fn void BamAlignment::SetIsDuplicate(bool ok) + \brief Sets value of "PCR duplicate" flag to \a ok. +*/ +void BamAlignment::SetIsDuplicate(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_DUPLICATE; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_DUPLICATE; +} - while ( numBytesParsed < tagDataLength ) { +/*! \fn void BamAlignment::SetIsFailedQC(bool ok) + \brief Sets "failed quality control" flag to \a ok. +*/ +void BamAlignment::SetIsFailedQC(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_QC_FAILED; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_QC_FAILED; +} - const char* pTagType = pTagData; - const char* pTagStorageType = pTagData + 2; - pTagData += 3; - numBytesParsed += 3; +/*! \fn void BamAlignment::SetIsFirstMate(bool ok) + \brief Sets "alignment is first mate" flag to \a ok. +*/ +void BamAlignment::SetIsFirstMate(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_READ_1; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_READ_1; +} - // check the current tag, return true on match - if ( std::strncmp(pTagType, tag.c_str(), 2) == 0 ) - return true; +/*! \fn void BamAlignment::SetIsMapped(bool ok) + \brief Sets "alignment is mapped" flag to \a ok. +*/ +void BamAlignment::SetIsMapped(bool ok) { + if (ok) AlignmentFlag &= ~Constants::BAM_ALIGNMENT_UNMAPPED; + else AlignmentFlag |= Constants::BAM_ALIGNMENT_UNMAPPED; +} - // get the storage class and find the next tag - if ( *pTagStorageType == '\0' ) return false; - if ( !SkipToNextTag(*pTagStorageType, pTagData, numBytesParsed) ) return false; - if ( *pTagData == '\0' ) return false; - } - - // checked all tags, none match - return false; +/*! \fn void BamAlignment::SetIsMateMapped(bool ok) + \brief Sets "alignment's mate is mapped" flag to \a ok. +*/ +void BamAlignment::SetIsMateMapped(bool ok) { + if (ok) AlignmentFlag &= ~Constants::BAM_ALIGNMENT_MATE_UNMAPPED; + else AlignmentFlag |= Constants::BAM_ALIGNMENT_MATE_UNMAPPED; } -bool BamAlignment::SkipToNextTag(const char storageType, char* &pTagData, unsigned int& numBytesParsed) { - - switch(storageType) { +/*! \fn void BamAlignment::SetIsMateUnmapped(bool ok) + \brief Complement of using SetIsMateMapped(). + \deprecated For sake of symmetry with the query methods + \sa IsMateMapped(), SetIsMateMapped() +*/ +void BamAlignment::SetIsMateUnmapped(bool ok) { + SetIsMateMapped(!ok); +} - case 'A': - case 'c': - case 'C': - ++numBytesParsed; - ++pTagData; - break; +/*! \fn void BamAlignment::SetIsMateReverseStrand(bool ok) + \brief Sets "alignment's mate mapped to reverse strand" flag to \a ok. +*/ +void BamAlignment::SetIsMateReverseStrand(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_MATE_REVERSE_STRAND; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_MATE_REVERSE_STRAND; +} - case 's': - case 'S': - numBytesParsed += 2; - pTagData += 2; - break; +/*! \fn void BamAlignment::SetIsPaired(bool ok) + \brief Sets "alignment part of paired-end read" flag to \a ok. +*/ +void BamAlignment::SetIsPaired(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_PAIRED; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_PAIRED; +} - case 'f': - case 'i': - case 'I': - numBytesParsed += 4; - pTagData += 4; - break; +/*! \fn void BamAlignment::SetIsPrimaryAlignment(bool ok) + \brief Sets "position is primary alignment" flag to \a ok. +*/ +void BamAlignment::SetIsPrimaryAlignment(bool ok) { + if (ok) AlignmentFlag &= ~Constants::BAM_ALIGNMENT_SECONDARY; + else AlignmentFlag |= Constants::BAM_ALIGNMENT_SECONDARY; +} - case 'Z': - case 'H': - while(*pTagData) { - ++numBytesParsed; - ++pTagData; - } - // increment for null-terminator - ++numBytesParsed; - ++pTagData; - break; +/*! \fn void BamAlignment::SetIsProperPair(bool ok) + \brief Sets "alignment is part of read that satisfied paired-end resolution" flag to \a ok. +*/ +void BamAlignment::SetIsProperPair(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_PROPER_PAIR; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_PROPER_PAIR; +} - default: - // error case - fprintf(stderr, "ERROR: Unknown tag storage class encountered: [%c]\n", storageType); - return false; - } - - // return success - return true; -} \ No newline at end of file +/*! \fn void BamAlignment::SetIsReverseStrand(bool ok) + \brief Sets "alignment mapped to reverse strand" flag to \a ok. +*/ +void BamAlignment::SetIsReverseStrand(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_REVERSE_STRAND; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_REVERSE_STRAND; +} + +/*! \fn void BamAlignment::SetIsSecondaryAlignment(bool ok) + \brief Complement of using SetIsPrimaryAlignment(). + \deprecated For sake of symmetry with the query methods + \sa IsPrimaryAlignment(), SetIsPrimaryAlignment() +*/ +void BamAlignment::SetIsSecondaryAlignment(bool ok) { + SetIsPrimaryAlignment(!ok); +} + +/*! \fn void BamAlignment::SetIsSecondMate(bool ok) + \brief Sets "alignment is second mate on read" flag to \a ok. +*/ +void BamAlignment::SetIsSecondMate(bool ok) { + if (ok) AlignmentFlag |= Constants::BAM_ALIGNMENT_READ_2; + else AlignmentFlag &= ~Constants::BAM_ALIGNMENT_READ_2; +} + +/*! \fn void BamAlignment::SetIsUnmapped(bool ok) + \brief Complement of using SetIsMapped(). + \deprecated For sake of symmetry with the query methods + \sa IsMapped(), SetIsMapped() +*/ +void BamAlignment::SetIsUnmapped(bool ok) { + SetIsMapped(!ok); +}