Loading...
Searching...
No Matches
SamFile Class Reference

Allows the user to easily read/write a SAM/BAM file. More...

`#include <SamFile.h>`

Inheritance diagram for SamFile:
[legend]
Collaboration diagram for SamFile:
[legend]

## Public Types

enum | OpenType { READ , WRITE }
| Enum for indicating whether to open the file for read or write. More...
enum | SortedType { UNSORTED = 0 , FLAG , COORDINATE , QUERY_NAME }
| Enum for indicating the type of sort expected in the file. More...

## Public Member Functions

| SamFile ()
| Default Constructor, initializes the variables, but does not open any files.
| SamFile (ErrorHandler::HandlingType errorHandlingType)
| Constructor that sets the error handling type.
| SamFile (const char *filename, OpenType mode)
| Constructor that opens the specified file based on the specified mode (READ/WRITE), aborts if the file could not be opened.
| SamFile (const char *filename, OpenType mode, ErrorHandler::HandlingType errorHandlingType)
| Constructor that opens the specified file based on the specified mode (READ/WRITE) and handles errors per the specified handleType.
| SamFile (const char *filename, OpenType mode, SamFileHeader *header)
| Constructor that opens the specified file based on the specified mode (READ/WRITE) and reads the header, aborts if the file could not be opened or the header not read.
| SamFile (const char *filename, OpenType mode, ErrorHandler::HandlingType errorHandlingType, SamFileHeader *header)
| Constructor that opens the specified file based on the specified mode (READ/WRITE) and reads the header, handling errors per the specified handleType.
virtual | ~SamFile ()
| Destructor.
bool | OpenForRead (const char *filename, SamFileHeader *header=NULL)
| Open a sam/bam file for reading with the specified filename, determing the type of file and SAM/BAM by reading the file (if not stdin).
bool | OpenForWrite (const char *filename, SamFileHeader *header=NULL)
| Open a sam/bam file for writing with the specified filename, determining SAM/BAM from the extension (.bam = BAM).
bool | ReadBamIndex (const char *filename)
| Read the specified bam index file.
bool | ReadBamIndex ()
| Read the bam index file using the BAM filename as a base.
void | SetReference (GenomeSequence *reference)
| Sets the reference to the specified genome sequence object.
void | SetReadSequenceTranslation (SamRecord::SequenceTranslation translation)
| Set the type of sequence translation to use when reading the sequence.
void | SetWriteSequenceTranslation (SamRecord::SequenceTranslation translation)
| Set the type of sequence translation to use when writing the sequence.
void | Close ()
| Close the file if there is one open.
bool | IsOpen ()
| Returns whether or not the file has been opened successfully.
bool | IsEOF ()
| Returns whether or not the end of the file has been reached.
bool | IsStream ()
| Returns whether or not the file has been opened for streaming input/output.
bool | ReadHeader (SamFileHeader &header)
| Reads the header section from the file and stores it in the passed in header.
bool | WriteHeader (SamFileHeader &header)
| Writes the specified header into the file.
bool | ReadRecord (SamFileHeader &header, SamRecord &record)
| Reads the next record from the file & stores it in the passed in record.
bool | WriteRecord (SamFileHeader &header, SamRecord &record)
| Writes the specified record into the file.
void | setSortedValidation (SortedType sortType)
| Set the flag to validate that the file is sorted as it is read/written.
uint32_t | GetCurrentRecordCount ()
| Return the number of records that have been read/written so far.
SamStatus::Status | GetFailure ()
| Deprecated, get the Status of the last call that sets status.
SamStatus::Status | GetStatus ()
| Get the Status of the last call that sets status.
const char * | GetStatusMessage ()
| Get the Status Message of the last call that sets status.
bool | SetReadSection (int32_t refID)
| Sets which reference id (index into the BAM list of reference information) of the BAM file should be read.
bool | SetReadSection (const char *refName)
| Sets which reference name of the BAM file should be read.
bool | SetReadSection (int32_t refID, int32_t start, int32_t end, bool overlap=true)
| Sets which reference id (index into the BAM list of reference information) & start/end positions of the BAM file should be read.
bool | SetReadSection (const char *refName, int32_t start, int32_t end, bool overlap=true)
| Sets which reference name & start/end positions of the BAM file should be read.
void | SetReadFlags (uint16_t requiredFlags, uint16_t excludedFlags)
| Specify which reads should be returned by ReadRecord.
int32_t | getNumMappedReadsFromIndex (int32_t refID)
| Get the number of mapped reads in the specified reference id.
int32_t | getNumUnMappedReadsFromIndex (int32_t refID)
| Get the number of unmapped reads in the specified reference id.
int32_t | getNumMappedReadsFromIndex (const char *refName, SamFileHeader &header)
| Get the number of mapped reads in the specified reference name.
int32_t | getNumUnMappedReadsFromIndex (const char *refName, SamFileHeader &header)
| Get the number of unmapped reads in the specified reference name.
uint32_t | GetNumOverlaps (SamRecord &samRecord)
| Returns the number of bases in the passed in read that overlap the region that is currently set.
void | GenerateStatistics (bool genStats)
| Whether or not statistics should be generated for this file.
const BamIndex * | GetBamIndex ()
| Return the bam index if one has been opened.
int64_t | GetCurrentPosition ()
| Get the current file position.
void | DisableBuffering ()
| Turn off file read buffering.
void | PrintStatistics ()
| Print the statistics that have been recorded due to a call to GenerateStatistics.
bool | attemptRecoverySync (bool(*checkSignature)(void *data), int length)
void | setAttemptRecovery (bool flag=false)

## Protected Member Functions

void | init ()
void | init (const char *filename, OpenType mode, SamFileHeader *header)
void | resetFile ()
| Resets the file prepping for a new file.
bool | validateSortOrder (SamRecord &record, SamFileHeader &header)
| Validate that the record is sorted compared to the previously read record if there is one, according to the specified sort order.
SortedType | getSortOrderFromHeader (SamFileHeader &header)
bool | processNewSection (SamFileHeader &header)
bool | ensureIndexedReadPosition ()
bool | checkRecordInSection (SamRecord &record)

## Protected Attributes

IFILE | myFilePtr
GenericSamInterface * | myInterfacePtr
bool | myIsOpenForRead
| Flag to indicate if a file is open for reading.
bool | myIsOpenForWrite
| Flag to indicate if a file is open for writing.
bool | myHasHeader
| Flag to indicate if a header has been read/written - required before being able to read/write a record.
SortedType | mySortedType
int32_t | myPrevCoord
| Previous values used for checking if the file is sorted.
int32_t | myPrevRefID
String | myPrevReadName
uint32_t | myRecordCount
| Keep a count of the number of records that have been read/written so far.
SamStatistics * | myStatistics
| Pointer to the statistics for this file.
SamStatus | myStatus
| The status of the last SamFile command.
bool | myIsBamOpenForRead
| Values for reading Sorted BAM files via the index.
bool | myNewSection
bool | myOverlapSection
int32_t | myRefID
int32_t | myStartPos
int32_t | myEndPos
uint64_t | myCurrentChunkEnd
SortedChunkList | myChunksToRead
BamIndex * | myBamIndex
GenomeSequence * | myRefPtr
SamRecord::SequenceTranslation | myReadTranslation
SamRecord::SequenceTranslation | myWriteTranslation
std::string | myRefName

## Detailed Description

Allows the user to easily read/write a SAM/BAM file.

The SamFile class contains additional functionality that allows a user to read specific sections of sorted & indexed BAM files. In order to take advantage of this capability, the index file must be read prior to setting the read section. This logic saves the time of having to read the entire file and takes advantage of the seeking capability of BGZF.

Definition at line 35 of file SamFile.h.

## Member Enumeration Documentation

## OpenType

enum SamFile::OpenType

Enum for indicating whether to open the file for read or write.

Enumerator
READ | open for reading.
WRITE | open for writing.

Definition at line 39 of file SamFile.h.

{
READ, ///< open for reading.
WRITE ///< open for writing.
};
SamFile::READ
@ READ
open for reading.
Definition SamFile.h:40
SamFile::WRITE
@ WRITE
open for writing.
Definition SamFile.h:41

## SortedType

enum SamFile::SortedType

Enum for indicating the type of sort expected in the file.

Enumerator
UNSORTED | file is not sorted.
FLAG | SO flag from the header indicates the sort type.
COORDINATE | file is sorted by coordinate.
QUERY_NAME | file is sorted by queryname.

Definition at line 46 of file SamFile.h.

{
UNSORTED = 0, ///< file is not sorted.
FLAG, ///< SO flag from the header indicates the sort type.
COORDINATE, ///< file is sorted by coordinate.
QUERY_NAME ///< file is sorted by queryname.
};
SamFile::UNSORTED
@ UNSORTED
file is not sorted.
Definition SamFile.h:47
SamFile::FLAG
@ FLAG
SO flag from the header indicates the sort type.
Definition SamFile.h:48
SamFile::QUERY_NAME
@ QUERY_NAME
file is sorted by queryname.
Definition SamFile.h:50
SamFile::COORDINATE
@ COORDINATE
file is sorted by coordinate.
Definition SamFile.h:49

## Constructor & Destructor Documentation

## SamFile() [1/6]

SamFile::SamFile | ( |  | ) |

Default Constructor, initializes the variables, but does not open any files.

Definition at line 26 of file SamFile.cpp.

: myStatus()
{
init();
resetFile();
}
SamFile::resetFile
void resetFile()
Resets the file prepping for a new file.
Definition SamFile.cpp:966
SamFile::myStatus
SamStatus myStatus
The status of the last SamFile command.
Definition SamFile.h:420

References resetFile().

## SamFile() [2/6]

SamFile::SamFile | ( | ErrorHandler::HandlingType | errorHandlingType | ) |

Constructor that sets the error handling type.

Parameters

  errorHandlingType | how to handle errors.

Definition at line 35 of file SamFile.cpp.

: myStatus(errorHandlingType)
{
init();
resetFile();
}

References resetFile().

## SamFile() [3/6]

SamFile::SamFile | ( | const char * | filename,
|  | OpenType | mode
| ) |  |

Constructor that opens the specified file based on the specified mode (READ/WRITE), aborts if the file could not be opened.

Parameters

  filename | name of the file to open.
  mode | mode to use for opening the file.

Definition at line 45 of file SamFile.cpp.

: myStatus()
{
init(filename, mode, NULL);
}

## SamFile() [4/6]

SamFile::SamFile | ( | const char * | filename,
|  | OpenType | mode,
|  | ErrorHandler::HandlingType | errorHandlingType
| ) |  |

Constructor that opens the specified file based on the specified mode (READ/WRITE) and handles errors per the specified handleType.

Parameters

  filename | name of the file to open.
  mode | mode to use for opening the file.
  errorHandlingType | how to handle errors.

Definition at line 54 of file SamFile.cpp.

: myStatus(errorHandlingType)
{
init(filename, mode, NULL);
}

## SamFile() [5/6]

SamFile::SamFile | ( | const char * | filename,
|  | OpenType | mode,
|  | SamFileHeader * | header
| ) |  |

Constructor that opens the specified file based on the specified mode (READ/WRITE) and reads the header, aborts if the file could not be opened or the header not read.

Parameters

  filename | name of the file to open.
  mode | mode to use for opening the file.
  header | to read into or write from

Definition at line 64 of file SamFile.cpp.

: myStatus()
{
init(filename, mode, header);
}

## SamFile() [6/6]

SamFile::SamFile | ( | const char * | filename,
|  | OpenType | mode,
|  | ErrorHandler::HandlingType | errorHandlingType,
|  | SamFileHeader * | header
| ) |  |

Constructor that opens the specified file based on the specified mode (READ/WRITE) and reads the header, handling errors per the specified handleType.

Parameters

  filename | name of the file to open.
  mode | mode to use for opening the file.
  errorHandlingType | how to handle errors.
  header | to read into or write from

Definition at line 73 of file SamFile.cpp.

: myStatus(errorHandlingType)
{
init(filename, mode, header);
}

## ~SamFile()

SamFile::~SamFile | ( |  | ) |

virtual

Destructor.

Definition at line 82 of file SamFile.cpp.

{
resetFile();
if(myStatistics != NULL)
{
delete myStatistics;
}
}
SamFile::myStatistics
SamStatistics * myStatistics
Pointer to the statistics for this file.
Definition SamFile.h:417

References myStatistics, and resetFile().

## Member Function Documentation

## attemptRecoverySync()

bool SamFile::attemptRecoverySync | ( | bool(*)(void *data) | checkSignature,
|  | int | length
| ) |  |

Definition at line 1365 of file SamFile.cpp.

{
if(myFilePtr==NULL) return false;
// non-recovery aware objects will just return false:
return myFilePtr->attemptRecoverySync(checkSignature, length);
}

## checkRecordInSection()

bool SamFile::checkRecordInSection | ( | SamRecord & | record | ) |

protected

Definition at line 1211 of file SamFile.cpp.

{
bool recordFound = true;
if(myRefID == BamIndex::REF_ID_ALL)
{
return(true);
}
// Check to see if it is in the correct reference/position.
if(record.getReferenceID() != myRefID)
{
// Incorrect reference ID, return no more records.
myStatus = SamStatus::NO_MORE_RECS;
return(false);
}
// Found a record.
recordFound = true;
// If start/end position are set, verify that the alignment falls
// within those.
// If the alignment start is greater than the end of the region,
// return NO_MORE_RECS.
// Since myEndPos is Exclusive 0-based, anything >= myEndPos is outside
// of the region.
if((myEndPos != -1) && (record.get0BasedPosition() >= myEndPos))
{
myStatus = SamStatus::NO_MORE_RECS;
return(false);
}
// We know the start is less than the end position, so the alignment
// overlaps the region if the alignment end position is greater than the
// start of the region.
if((myStartPos != -1) && (record.get0BasedAlignmentEnd() < myStartPos))
{
// If it does not overlap the region, so go to the next
// record...set recordFound back to false.
recordFound = false;
}
if(!myOverlapSection)
{
// Needs to be fully contained. Not fully contained if
// 1) the record start position is < the region start position.
// or
// 2) the end position is specified and the record end position
// is greater than or equal to the region end position.
// (equal to since the region is exclusive.
if((record.get0BasedPosition() < myStartPos) ||
((myEndPos != -1) &&
(record.get0BasedAlignmentEnd() >= myEndPos)))
{
// This record is not fully contained, so move on to the next
// record.
recordFound = false;
}
}
return(recordFound);
}
BamIndex::REF_ID_ALL
static const int32_t REF_ID_ALL
The number used to indicate that all reference ids should be used.
Definition BamIndex.h:89
SamRecord::getReferenceID
int32_t getReferenceID()
Get the reference sequence id of the record (BAM format rid).
Definition SamRecord.cpp:1305
SamRecord::get0BasedAlignmentEnd
int32_t get0BasedAlignmentEnd()
Returns the 0-based inclusive rightmost position of the clipped sequence.
Definition SamRecord.cpp:1467
SamRecord::get0BasedPosition
int32_t get0BasedPosition()
Get the 0-based(BAM) leftmost position of the record.
Definition SamRecord.cpp:1319
StatGenStatus::NO_MORE_RECS
@ NO_MORE_RECS
NO_MORE_RECS: failed to read a record since there are no more to read either in the file or section i...
Definition StatGenStatus.h:36

## Close()

void SamFile::Close | ( |  | ) |

Close the file if there is one open.

Definition at line 400 of file SamFile.cpp.

{
// Resetting the file will close it if it is open, and
// will reset all other variables.
resetFile();
}

References resetFile().

## DisableBuffering()

void SamFile::DisableBuffering | ( |  | ) |

inline

Turn off file read buffering.

Definition at line 347 of file SamFile.h.

{
if(myFilePtr != NULL)
{
myFilePtr->disableBuffering();
}
}
InputFile::disableBuffering
void disableBuffering()
Disable read buffering.
Definition InputFile.h:121

References InputFile::disableBuffering().

## ensureIndexedReadPosition()

bool SamFile::ensureIndexedReadPosition | ( |  | ) |

protected

Definition at line 1166 of file SamFile.cpp.

{
// If no sections are specified, return true.
if(myRefID == BamIndex::REF_ID_ALL)
{
return(true);
}
// Check to see if we have more to read out of the current chunk.
// By checking the current position in relation to the current
// end chunk. If the current position is >= the end of the
// current chunk, then we must see to the next chunk.
uint64_t currentPos = iftell(myFilePtr);
if(currentPos >= myCurrentChunkEnd)
{
// If there are no more chunks to process, return failure.
if(myChunksToRead.empty())
{
myStatus = SamStatus::NO_MORE_RECS;
return(false);
}
// There are more chunks left, so get the next chunk.
Chunk newChunk = myChunksToRead.pop();
// Move to the location of the new chunk if it is not adjacent
// to the current chunk.
if(newChunk.chunk_beg != currentPos)
{
// New chunk is not adjacent, so move to it.
if(ifseek(myFilePtr, newChunk.chunk_beg, SEEK_SET) != true)
{
// seek failed, cannot retrieve next record, return failure.
myStatus.setStatus(SamStatus::FAIL_IO,
"Failed to seek to the next record");
return(false);
}
}
// Seek succeeded, set the end of the new chunk.
myCurrentChunkEnd = newChunk.chunk_end;
}
return(true);
}
ifseek
bool ifseek(IFILE file, int64_t offset, int origin)
Seek to the specified position (result from an iftell), but cannot be done for stdin/stdout.
Definition InputFile.h:701
iftell
int64_t iftell(IFILE file)
Get current position in the file.
Definition InputFile.h:682
Chunk
Definition IndexBase.h:31
StatGenStatus::FAIL_IO
@ FAIL_IO
method failed due to an I/O issue.
Definition StatGenStatus.h:37
StatGenStatus::setStatus
void setStatus(Status newStatus, const char *newMessage)
Set the status with the specified status enum and message.
Definition StatGenStatus.cpp:83

## GenerateStatistics()

void SamFile::GenerateStatistics | ( | bool | genStats | ) |

Whether or not statistics should be generated for this file.

The value is carried over between files and is not reset, but the statistics themselves are reset between files.

Parameters

  genStats | set to true if statistics should be generated, false if not.

Definition at line 891 of file SamFile.cpp.

{
if(genStats)
{
if(myStatistics == NULL)
{
// Want to generate statistics, but do not yet have the
// structure for them, so create one.
myStatistics = new SamStatistics();
}
}
else
{
// Do not generate statistics, so if myStatistics is not NULL,
// delete it.
if(myStatistics != NULL)
{
delete myStatistics;
myStatistics = NULL;
}
}
}
SamStatistics
Definition SamStatistics.h:25

References myStatistics.

## GetBamIndex()

const BamIndex * SamFile::GetBamIndex | ( |  | ) |

Return the bam index if one has been opened.

Returns
  const pointer to the bam index, or null if one has not been opened.

Definition at line 916 of file SamFile.cpp.

{
return(myBamIndex);
}

## GetCurrentPosition()

int64_t SamFile::GetCurrentPosition | ( |  | ) |

inline

Get the current file position.

Returns
  current position in the file.

Definition at line 341 of file SamFile.h.

{
return(iftell(myFilePtr));
}

References iftell().

## GetCurrentRecordCount()

uint32_t SamFile::GetCurrentRecordCount | ( |  | ) |

Return the number of records that have been read/written so far.

Definition at line 689 of file SamFile.cpp.

{
return(myRecordCount);
}
SamFile::myRecordCount
uint32_t myRecordCount
Keep a count of the number of records that have been read/written so far.
Definition SamFile.h:414

References myRecordCount.

## GetFailure()

SamStatus::Status SamFile::GetFailure | ( |  | ) |

inline

Deprecated, get the Status of the last call that sets status.

To remain backwards compatable - will be removed later.

Definition at line 206 of file SamFile.h.

{
return(GetStatus());
}
SamFile::GetStatus
SamStatus::Status GetStatus()
Get the Status of the last call that sets status.
Definition SamFile.h:212

References GetStatus().

## getNumMappedReadsFromIndex() [1/2]

int32_t SamFile::getNumMappedReadsFromIndex | ( | const char * | refName,
|  | SamFileHeader & | header
| ) |  |

Get the number of mapped reads in the specified reference name.

Returns -1 for unknown reference names.

Parameters

  refName | reference name for which to extract the number of mapped reads.
  header | header object containing the map from refName to refID

Returns
  number of mapped reads for the specified reference name.

Definition at line 833 of file SamFile.cpp.

{
// The bam index must have already been read.
if(myBamIndex == NULL)
{
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot get num mapped reads from the index until it has been read.");
return(false);
}
int32_t refID = BamIndex::REF_ID_UNMAPPED;
if((strcmp(refName, "") != 0) && (strcmp(refName, "*") != 0))
{
// Reference name specified, so read just the "-1" entries.
refID = header.getReferenceID(refName);
}
return(myBamIndex->getNumMappedReads(refID));
}
BamIndex::getNumMappedReads
int32_t getNumMappedReads(int32_t refID)
Get the number of mapped reads for this reference id.
Definition BamIndex.cpp:355
BamIndex::REF_ID_UNMAPPED
static const int32_t REF_ID_UNMAPPED
The number used for the reference id of unmapped reads.
Definition BamIndex.h:86
SamFileHeader::getReferenceID
int getReferenceID(const String &referenceName, bool addID=false)
Get the reference ID for the specified reference name (chromosome).
Definition SamFileHeader.cpp:146
StatGenStatus::FAIL_ORDER
@ FAIL_ORDER
FAIL_ORDER: method failed because it was called out of order, like trying to read a file without open...
Definition StatGenStatus.h:41

References StatGenStatus::FAIL_ORDER, BamIndex::getNumMappedReads(), SamFileHeader::getReferenceID(), myStatus, BamIndex::REF_ID_UNMAPPED, and StatGenStatus::setStatus().

## getNumMappedReadsFromIndex() [2/2]

int32_t SamFile::getNumMappedReadsFromIndex | ( | int32_t | refID | ) |

Get the number of mapped reads in the specified reference id.

Returns -1 for out of range refIDs.

Parameters

  refID | reference ID for which to extract the number of mapped reads.

Returns
  number of mapped reads for the specified reference id.

Definition at line 803 of file SamFile.cpp.

{
// The bam index must have already been read.
if(myBamIndex == NULL)
{
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot get num mapped reads from the index until it has been read.");
return(false);
}
return(myBamIndex->getNumMappedReads(refID));
}

References StatGenStatus::FAIL_ORDER, BamIndex::getNumMappedReads(), myStatus, and StatGenStatus::setStatus().

## GetNumOverlaps()

uint32_t SamFile::GetNumOverlaps | ( | SamRecord & | samRecord | ) |

Returns the number of bases in the passed in read that overlap the region that is currently set.

Overlapping means that the bases occur in both the read and the reference as either matches or mismatches. This does not count insertions, deletions, clips, pads, or skips.

Parameters

  samRecord | to check for overlapping bases.

Returns
  number of bases that overlap region that is currently set.

Definition at line 877 of file SamFile.cpp.

{
if(myRefPtr != NULL)
{
samRecord.setReference(myRefPtr);
}
samRecord.setSequenceTranslation(myReadTranslation);
// Get the overlaps in the sam record for the region currently set
// for this file.
return(samRecord.getNumOverlaps(myStartPos, myEndPos));
}
SamRecord::setSequenceTranslation
void setSequenceTranslation(SequenceTranslation translation)
Set the type of sequence translation to use when getting the sequence.
Definition SamRecord.cpp:187
SamRecord::getNumOverlaps
uint32_t getNumOverlaps(int32_t start, int32_t end)
Return the number of bases in this read that overlap the passed in region.
Definition SamRecord.cpp:1853
SamRecord::setReference
void setReference(GenomeSequence *reference)
Set the reference to the specified genome sequence object.
Definition SamRecord.cpp:178

References SamRecord::getNumOverlaps(), SamRecord::setReference(), and SamRecord::setSequenceTranslation().

## getNumUnMappedReadsFromIndex() [1/2]

int32_t SamFile::getNumUnMappedReadsFromIndex | ( | const char * | refName,
|  | SamFileHeader & | header
| ) |  |

Get the number of unmapped reads in the specified reference name.

Returns -1 for unknown reference names.

Parameters

  refName | reference name for which to extract the number of unmapped reads.
  header | header object containing the map from refName to refID

Returns
  number of unmapped reads for the specified reference name.

Definition at line 855 of file SamFile.cpp.

{
// The bam index must have already been read.
if(myBamIndex == NULL)
{
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot get num unmapped reads from the index until it has been read.");
return(false);
}
int32_t refID = BamIndex::REF_ID_UNMAPPED;
if((strcmp(refName, "") != 0) && (strcmp(refName, "*") != 0))
{
// Reference name specified, so read just the "-1" entries.
refID = header.getReferenceID(refName);
}
return(myBamIndex->getNumUnMappedReads(refID));
}
BamIndex::getNumUnMappedReads
int32_t getNumUnMappedReads(int32_t refID)
Get the number of unmapped reads for this reference id.
Definition BamIndex.cpp:377

References StatGenStatus::FAIL_ORDER, BamIndex::getNumUnMappedReads(), SamFileHeader::getReferenceID(), myStatus, BamIndex::REF_ID_UNMAPPED, and StatGenStatus::setStatus().

## getNumUnMappedReadsFromIndex() [2/2]

int32_t SamFile::getNumUnMappedReadsFromIndex | ( | int32_t | refID | ) |

Get the number of unmapped reads in the specified reference id.

Returns -1 for out of range refIDs.

Parameters

  refID | reference ID for which to extract the number of unmapped reads.

Returns
  number of unmapped reads for the specified reference id.

Definition at line 818 of file SamFile.cpp.

{
// The bam index must have already been read.
if(myBamIndex == NULL)
{
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot get num unmapped reads from the index until it has been read.");
return(false);
}
return(myBamIndex->getNumUnMappedReads(refID));
}

References StatGenStatus::FAIL_ORDER, BamIndex::getNumUnMappedReads(), myStatus, and StatGenStatus::setStatus().

## getSortOrderFromHeader()

SamFile::SortedType SamFile::getSortOrderFromHeader | ( | SamFileHeader & | header | ) |

protected

Definition at line 1147 of file SamFile.cpp.

{
const char* tag = header.getSortOrder();
// Default to unsorted since if it is not specified in the header
// that is the value that should be used.
SortedType headerSortOrder = UNSORTED;
if(strcmp(tag, "queryname") == 0)
{
headerSortOrder = QUERY_NAME;
}
else if(strcmp(tag, "coordinate") == 0)
{
headerSortOrder = COORDINATE;
}
return(headerSortOrder);
}
SamFileHeader::getSortOrder
const char * getSortOrder()
Return the Sort Order value that is set in the Header, returning "" if this field does not exist.
Definition SamFileHeader.cpp:797
SamFile::SortedType
SortedType
Enum for indicating the type of sort expected in the file.
Definition SamFile.h:46

## GetStatus()

SamStatus::Status SamFile::GetStatus | ( |  | ) |

inline

Get the Status of the last call that sets status.

Definition at line 212 of file SamFile.h.

{
return(myStatus.getStatus());
}
StatGenStatus::getStatus
Status getStatus() const
Return the enum for this status object.
Definition StatGenStatus.cpp:142

References StatGenStatus::getStatus(), and myStatus.

Referenced by GetFailure(), and Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile().

## GetStatusMessage()

const char * SamFile::GetStatusMessage | ( |  | ) |

inline

Get the Status Message of the last call that sets status.

Definition at line 218 of file SamFile.h.

{
return(myStatus.getStatusMessage());
}
StatGenStatus::getStatusMessage
const char * getStatusMessage() const
Return the status message for this object.
Definition StatGenStatus.cpp:149

References StatGenStatus::getStatusMessage(), and myStatus.

Referenced by Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile().

## init() [1/2]

void SamFile::init | ( |  | ) |

protected

Definition at line 923 of file SamFile.cpp.

{
myFilePtr = NULL;
myInterfacePtr = NULL;
myStatistics = NULL;
myBamIndex = NULL;
myRefPtr = NULL;
myReadTranslation = SamRecord::NONE;
myWriteTranslation = SamRecord::NONE;
myAttemptRecovery = false;
myRequiredFlags = 0;
myExcludedFlags = 0;
}
SamRecord::NONE
@ NONE
Leave the sequence as is.
Definition SamRecord.h:58

## init() [2/2]

void SamFile::init | ( | const char * | filename,
|  | OpenType | mode,
|  | SamFileHeader * | header
| ) |  |

protected

Definition at line 938 of file SamFile.cpp.

{
init();
resetFile();
bool openStatus = true;
if(mode == READ)
{
// open the file for read.
openStatus = OpenForRead(filename, header);
}
else
{
// open the file for write.
openStatus = OpenForWrite(filename, header);
}
if(!openStatus)
{
// Failed to open the file - print error and abort.
fprintf(stderr, "%s\n", GetStatusMessage());
std::cerr << "FAILURE - EXITING!!!" << std::endl;
exit(-1);
}
}
SamFile::OpenForRead
bool OpenForRead(const char *filename, SamFileHeader *header=NULL)
Open a sam/bam file for reading with the specified filename, determing the type of file and SAM/BAM b...
Definition SamFile.cpp:93
SamFile::OpenForWrite
bool OpenForWrite(const char *filename, SamFileHeader *header=NULL)
Open a sam/bam file for writing with the specified filename, determining SAM/BAM from the extension (...
Definition SamFile.cpp:223
SamFile::GetStatusMessage
const char * GetStatusMessage()
Get the Status Message of the last call that sets status.
Definition SamFile.h:218

## IsEOF()

bool SamFile::IsEOF | ( |  | ) |

Returns whether or not the end of the file has been reached.

Returns
  true = EOF; false = not eof. If the file is not open, true is returned.

Definition at line 424 of file SamFile.cpp.

{
if(myIsOpenForRead == false)
{
// Not open for read, return true.
return(true);
}
return(myInterfacePtr->isEOF(myFilePtr));
}
SamFile::myIsOpenForRead
bool myIsOpenForRead
Flag to indicate if a file is open for reading.
Definition SamFile.h:399

References myIsOpenForRead.

## IsOpen()

bool SamFile::IsOpen | ( |  | ) |

Returns whether or not the file has been opened successfully.

Returns
  true = open; false = not open.

Definition at line 410 of file SamFile.cpp.

{
if (myFilePtr != NULL)
{
// File Pointer is set, so return if it is open.
return(myFilePtr->isOpen());
}
// File pointer is not set, so return false, not open.
return false;
}
InputFile::isOpen
bool isOpen() const
Returns whether or not the file was successfully opened.
Definition InputFile.h:423

References InputFile::isOpen().

## IsStream()

bool SamFile::IsStream | ( |  | ) |

Returns whether or not the file has been opened for streaming input/output.

Returns
  true = stream; false = not a stream.

Definition at line 437 of file SamFile.cpp.

{
if (myFilePtr != NULL)
{
// File Pointer is set, so return if it is a stream.
return((myFilePtr->getFileName())[0] == '-');
}
// File pointer is not set, so return false, not a stream.
return false;
}
InputFile::getFileName
const char * getFileName() const
Get the filename that is currently opened.
Definition InputFile.h:473

References InputFile::getFileName().

## OpenForRead()

bool SamFile::OpenForRead | ( | const char * | filename,
|  | SamFileHeader * | header = `NULL`
| ) |  |

Open a sam/bam file for reading with the specified filename, determing the type of file and SAM/BAM by reading the file (if not stdin).

Parameters

  filename | the sam/bam file to open for reading.
  header | to read into or write from (optional)

Returns
  true = success; false = failure.

Definition at line 93 of file SamFile.cpp.

{
// Reset for any previously operated on files.
resetFile();
int lastchar = 0;
while (filename[lastchar] != 0) lastchar++;
// If at least one character, check for '-'.
if((lastchar >= 1) && (filename[0] == '-'))
{
// Read from stdin - determine type of file to read.
// Determine if compressed bam.
if(strcmp(filename, "-.bam") == 0)
{
// Compressed bam - open as bgzf.
// -.bam is the filename, read compressed bam from stdin
filename = "-";
myFilePtr = new InputFile;
// support recover mode - this switches in a reader
// capable of recovering from bad BGZF compression blocks.
myFilePtr->setAttemptRecovery(myAttemptRecovery);
myFilePtr->openFile(filename, "rb", InputFile::BGZF);
myInterfacePtr = new BamInterface;
// Read the magic string.
char magic[4];
ifread(myFilePtr, magic, 4);
}
else if(strcmp(filename, "-.ubam") == 0)
{
// uncompressed BAM File.
// -.ubam is the filename, read uncompressed bam from stdin.
// uncompressed BAM is still compressed with BGZF, but using
// compression level 0, so still open as BGZF since it has a
// BGZF header.
filename = "-";
// Uncompressed, so do not require the eof block.
#ifdef __ZLIB_AVAILABLE__
BgzfFileType::setRequireEofBlock(false);
#endif
myFilePtr = ifopen(filename, "rb", InputFile::BGZF);
myInterfacePtr = new BamInterface;
// Read the magic string.
char magic[4];
ifread(myFilePtr, magic, 4);
}
else if((strcmp(filename, "-") == 0) || (strcmp(filename, "-.sam") == 0))
{
// SAM File.
// read sam from stdin
filename = "-";
myFilePtr = ifopen(filename, "rb", InputFile::UNCOMPRESSED);
myInterfacePtr = new SamInterface;
}
else
{
std::string errorMessage = "Invalid SAM/BAM filename, ";
errorMessage += filename;
errorMessage += ". From stdin, can only be '-', '-.sam', '-.bam', or '-.ubam'";
myStatus.setStatus(SamStatus::FAIL_IO, errorMessage.c_str());
delete myFilePtr;
myFilePtr = NULL;
return(false);
}
}
else
{
// Not from stdin. Read the file to determine the type.
myFilePtr = new InputFile;
// support recovery mode - this conditionally enables a reader
// capable of recovering from bad BGZF compression blocks.
myFilePtr->setAttemptRecovery(myAttemptRecovery);
bool rc = myFilePtr->openFile(filename, "rb", InputFile::DEFAULT);
if (rc == false)
{
std::string errorMessage = "Failed to Open ";
errorMessage += filename;
errorMessage += " for reading";
myStatus.setStatus(SamStatus::FAIL_IO, errorMessage.c_str());
delete myFilePtr;
myFilePtr = NULL;
return(false);
}
char magic[4];
ifread(myFilePtr, magic, 4);
if (magic[0] == 'B' && magic[1] == 'A' && magic[2] == 'M' &&
magic[3] == 1)
{
myInterfacePtr = new BamInterface;
// Set that it is a bam file open for reading. This is needed to
// determine if an index file can be used.
myIsBamOpenForRead = true;
}
else
{
// Not a bam, so rewind to the beginning of the file so it
// can be read.
ifrewind(myFilePtr);
myInterfacePtr = new SamInterface;
}
}
// File is open for reading.
myIsOpenForRead = true;
// Read the header if one was passed in.
if(header != NULL)
{
return(ReadHeader(*header));
}
// Successfully opened the file.
myStatus = SamStatus::SUCCESS;
return(true);
}
ifrewind
void ifrewind(IFILE file)
Reset to the beginning of the file (cannot be done for stdin/stdout).
Definition InputFile.h:642
ifopen
IFILE ifopen(const char *filename, const char *mode, InputFile::ifileCompression compressionMode=InputFile::DEFAULT)
Open a file with the specified name and mode, using a filename of "-" to indicate stdin/stdout.
Definition InputFile.h:562
ifread
unsigned int ifread(IFILE file, void *buffer, unsigned int size)
Read up to size bytes from the file into the buffer.
Definition InputFile.h:600
BamInterface
Definition BamInterface.h:24
InputFile
Class for easily reading/writing files without having to worry about file type (uncompressed,...
Definition InputFile.h:37
InputFile::setAttemptRecovery
void setAttemptRecovery(bool flag=false)
Enable (default) or disable recovery.
Definition InputFile.h:485
InputFile::BGZF
@ BGZF
bgzf file.
Definition InputFile.h:48
InputFile::DEFAULT
@ DEFAULT
Check the extension, if it is ".gz", treat as gzip, otherwise treat it as UNCOMPRESSED.
Definition InputFile.h:45
InputFile::UNCOMPRESSED
@ UNCOMPRESSED
uncompressed file.
Definition InputFile.h:46
SamFile::ReadHeader
bool ReadHeader(SamFileHeader &header)
Reads the header section from the file and stores it in the passed in header.
Definition SamFile.cpp:450
SamFile::myIsBamOpenForRead
bool myIsBamOpenForRead
Values for reading Sorted BAM files via the index.
Definition SamFile.h:423
SamInterface
Definition SamInterface.h:24
StatGenStatus::SUCCESS
@ SUCCESS
method completed successfully.
Definition StatGenStatus.h:32

References InputFile::BGZF, InputFile::DEFAULT, StatGenStatus::FAIL_IO, ifopen(), ifread(), ifrewind(), myIsBamOpenForRead, myIsOpenForRead, myStatus, ReadHeader(), resetFile(), InputFile::setAttemptRecovery(), StatGenStatus::setStatus(), StatGenStatus::SUCCESS, and InputFile::UNCOMPRESSED.

Referenced by Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile().

## OpenForWrite()

bool SamFile::OpenForWrite | ( | const char * | filename,
|  | SamFileHeader * | header = `NULL`
| ) |  |

Open a sam/bam file for writing with the specified filename, determining SAM/BAM from the extension (.bam = BAM).

Parameters

  filename | the sam/bam file to open for writing.
  header | to read into or write from (optional)

Returns
  true = success; false = failure.

Definition at line 223 of file SamFile.cpp.

{
// Reset for any previously operated on files.
resetFile();
int lastchar = 0;
while (filename[lastchar] != 0) lastchar++;
if (lastchar >= 4 &&
filename[lastchar - 4] == 'u' &&
filename[lastchar - 3] == 'b' &&
filename[lastchar - 2] == 'a' &&
filename[lastchar - 1] == 'm')
{
// BAM File.
// if -.ubam is the filename, write uncompressed bam to stdout
if((lastchar == 6) && (filename[0] == '-') && (filename[1] == '.'))
{
filename = "-";
}
myFilePtr = ifopen(filename, "wb0", InputFile::BGZF);
myInterfacePtr = new BamInterface;
}
else if (lastchar >= 3 &&
filename[lastchar - 3] == 'b' &&
filename[lastchar - 2] == 'a' &&
filename[lastchar - 1] == 'm')
{
// BAM File.
// if -.bam is the filename, write compressed bam to stdout
if((lastchar == 5) && (filename[0] == '-') && (filename[1] == '.'))
{
filename = "-";
}
myFilePtr = ifopen(filename, "wb", InputFile::BGZF);
myInterfacePtr = new BamInterface;
}
else
{
// SAM File
// if - (followed by anything is the filename,
// write uncompressed sam to stdout
if((lastchar >= 1) && (filename[0] == '-'))
{
filename = "-";
}
myFilePtr = ifopen(filename, "wb", InputFile::UNCOMPRESSED);
myInterfacePtr = new SamInterface;
}
if (myFilePtr == NULL)
{
std::string errorMessage = "Failed to Open ";
errorMessage += filename;
errorMessage += " for writing";
myStatus.setStatus(SamStatus::FAIL_IO, errorMessage.c_str());
return(false);
}
myIsOpenForWrite = true;
// Write the header if one was passed in.
if(header != NULL)
{
return(WriteHeader(*header));
}
// Successfully opened the file.
myStatus = SamStatus::SUCCESS;
return(true);
}
SamFile::WriteHeader
bool WriteHeader(SamFileHeader &header)
Writes the specified header into the file.
Definition SamFile.cpp:480
SamFile::myIsOpenForWrite
bool myIsOpenForWrite
Flag to indicate if a file is open for writing.
Definition SamFile.h:401

References InputFile::BGZF, StatGenStatus::FAIL_IO, ifopen(), myIsOpenForWrite, myStatus, resetFile(), StatGenStatus::setStatus(), StatGenStatus::SUCCESS, InputFile::UNCOMPRESSED, and WriteHeader().

## PrintStatistics()

void SamFile::PrintStatistics | ( |  | ) |

inline

Print the statistics that have been recorded due to a call to GenerateStatistics.

Definition at line 357 of file SamFile.h.

{if(myStatistics != NULL) myStatistics->print();}

References myStatistics.

## processNewSection()

bool SamFile::processNewSection | ( | SamFileHeader & | header | ) |

protected

Definition at line 1273 of file SamFile.cpp.

{
myNewSection = false;
// If there is no index file, return failure.
if(myBamIndex == NULL)
{
// No bam index has been read.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot read section since there is no index file open");
throw(std::runtime_error("SOFTWARE BUG: trying to read a BAM record by section prior to opening the BAM Index file."));
return(false);
}
// If there is not a BAM file open for reading, return failure.
if(!myIsBamOpenForRead)
{
// There is not a BAM file open for reading.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot read section since there is no bam file open");
throw(std::runtime_error("SOFTWARE BUG: trying to read a BAM record by section without opening a BAM file."));
return(false);
}
if(myHasHeader == false)
{
// The header has not yet been read.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot read record since the header has not been read.");
throw(std::runtime_error("SOFTWARE BUG: trying to read a BAM record by section prior to opening the header."));
return(false);
}
// Indexed Bam open for read, so disable read buffering because iftell
// will be used.
// Needs to be done here after we already know that the header has been
// read.
myFilePtr->disableBuffering();
myChunksToRead.clear();
// Reset the end of the current chunk. We are resetting our read, so
// we no longer have a "current chunk" that we are reading.
myCurrentChunkEnd = 0;
// Check to see if the read section was set based on the reference name
// but not yet converted to reference id.
if(!myRefName.empty())
{
myRefID = header.getReferenceID(myRefName.c_str());
// Clear the myRefName length so this code is only executed once.
myRefName.clear();
// Check to see if a reference id was found.
if(myRefID == SamReferenceInfo::NO_REF_ID)
{
myStatus = SamStatus::NO_MORE_RECS;
return(false);
}
}
// Get the chunks associated with this reference region.
if(myBamIndex->getChunksForRegion(myRefID, myStartPos, myEndPos,
myChunksToRead) == true)
{
myStatus = SamStatus::SUCCESS;
}
else
{
String errorMsg = "Failed to get the specified region, refID = ";
errorMsg += myRefID;
errorMsg += "; startPos = ";
errorMsg += myStartPos;
errorMsg += "; endPos = ";
errorMsg += myEndPos;
myStatus.setStatus(SamStatus::FAIL_PARSE,
errorMsg);
}
return(true);
}
BamIndex::getChunksForRegion
bool getChunksForRegion(int32_t refID, int32_t start, int32_t end, SortedChunkList &chunkList)
Get the list of chunks associated with this region.
Definition BamIndex.cpp:218
SamFile::myHasHeader
bool myHasHeader
Flag to indicate if a header has been read/written - required before being able to read/write a recor...
Definition SamFile.h:404
SamReferenceInfo::NO_REF_ID
static const int NO_REF_ID
Constant for the value returned if a reference id does not exist for a queried reference name.
Definition SamReferenceInfo.h:77
StatGenStatus::FAIL_PARSE
@ FAIL_PARSE
failed to parse a record/header - invalid format.
Definition StatGenStatus.h:42
String
Definition StringBasics.h:39

## ReadBamIndex() [1/2]

bool SamFile::ReadBamIndex | ( |  | ) |

Read the bam index file using the BAM filename as a base.

It must be read prior to setting a read section, for seeking and reading portions of a bam file. Must be read after opening the BAM file since it uses the BAM filename as a base name for the index file. First it tries filename.bam.bai. If that fails, it tries it without the .bam extension, filename.bai.

Returns
  true = success; false = failure.

Definition at line 328 of file SamFile.cpp.

{
if(myFilePtr == NULL)
{
// Can't read the bam index file because the BAM file has not yet been
// opened, so we don't know the base filename for the index file.
std::string errorMessage = "Failed to read the bam Index file -"
" the BAM file needs to be read first in order to determine"
" the index filename.";
myStatus.setStatus(SamStatus::FAIL_ORDER, errorMessage.c_str());
return(false);
}
const char* bamBaseName = myFilePtr->getFileName();
std::string indexName = bamBaseName;
indexName += ".bai";
bool foundFile = true;
try
{
if(ReadBamIndex(indexName.c_str()) == false)
{
foundFile = false;
}
}
catch (std::exception&)
{
foundFile = false;
}
// Check to see if the index file was found.
if(!foundFile)
{
// Not found - try without the bam extension.
// Locate the start of the bam extension
size_t startExt = indexName.find(".bam");
if(startExt == std::string::npos)
{
// Could not find the .bam extension, so just return false since the
// call to ReadBamIndex set the status.
return(false);
}
// Remove ".bam" and try reading the index again.
indexName.erase(startExt, 4);
return(ReadBamIndex(indexName.c_str()));
}
return(true);
}
SamFile::ReadBamIndex
bool ReadBamIndex()
Read the bam index file using the BAM filename as a base.
Definition SamFile.cpp:328

References StatGenStatus::FAIL_ORDER, InputFile::getFileName(), myStatus, ReadBamIndex(), and StatGenStatus::setStatus().

Referenced by ReadBamIndex().

## ReadBamIndex() [2/2]

bool SamFile::ReadBamIndex | ( | const char * | filename | ) |

Read the specified bam index file.

It must be read prior to setting a read section, for seeking and reading portions of a bam file.

Parameters

  filename | the name of the bam index file to be read.

Returns
  true = success; false = failure.

Definition at line 300 of file SamFile.cpp.

{
// Cleanup a previously setup index.
if(myBamIndex != NULL)
{
delete myBamIndex;
myBamIndex = NULL;
}
// Create a new bam index.
myBamIndex = new BamIndex();
SamStatus::Status indexStat = myBamIndex->readIndex(bamIndexFilename);
if(indexStat != SamStatus::SUCCESS)
{
std::string errorMessage = "Failed to read the bam Index file: ";
errorMessage += bamIndexFilename;
myStatus.setStatus(indexStat, errorMessage.c_str());
delete myBamIndex;
myBamIndex = NULL;
return(false);
}
myStatus = SamStatus::SUCCESS;
return(true);
}
BamIndex
Definition BamIndex.h:32
BamIndex::readIndex
SamStatus::Status readIndex(const char *filename)
Definition BamIndex.cpp:45
StatGenStatus::Status
Status
Return value enum for StatGenFile methods.
Definition StatGenStatus.h:32

References myStatus, BamIndex::readIndex(), StatGenStatus::setStatus(), and StatGenStatus::SUCCESS.

## ReadHeader()

bool SamFile::ReadHeader | ( | SamFileHeader & | header | ) |

Reads the header section from the file and stores it in the passed in header.

Returns
  true = success; false = failure.

Definition at line 450 of file SamFile.cpp.

{
myStatus = SamStatus::SUCCESS;
if(myIsOpenForRead == false)
{
// File is not open for read
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot read header since the file is not open for reading");
return(false);
}
if(myHasHeader == true)
{
// The header has already been read.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot read header since it has already been read.");
return(false);
}
if(myInterfacePtr->readHeader(myFilePtr, header, myStatus))
{
// The header has now been successfully read.
myHasHeader = true;
return(true);
}
return(false);
}

References StatGenStatus::FAIL_ORDER, myHasHeader, myIsOpenForRead, myStatus, StatGenStatus::setStatus(), and StatGenStatus::SUCCESS.

Referenced by OpenForRead(), and Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile().

## ReadRecord()

bool SamFile::ReadRecord | ( | SamFileHeader & | header,
|  | SamRecord & | record
| ) |  |

Reads the next record from the file & stores it in the passed in record.

If it is an indexed BAM file and SetReadSection was called, only alignments in the section specified by SetReadSection are read. If they all have already been read, this method returns false.

Validates that the record is sorted according to the value set by setSortedValidation. No sorting validation is done if specified to be unsorted, or setSortedValidation was never called.

Returns
  true = record was successfully set (and sorted if applicable), false = record was not successfully set (or not sorted as expected).

Definition at line 514 of file SamFile.cpp.

{
myStatus = SamStatus::SUCCESS;
if(myIsOpenForRead == false)
{
// File is not open for read
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot read record since the file is not open for reading");
throw(std::runtime_error("SOFTWARE BUG: trying to read a SAM/BAM record prior to opening the file."));
return(false);
}
if(myHasHeader == false)
{
// The header has not yet been read.
// TODO - maybe just read the header.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot read record since the header has not been read.");
throw(std::runtime_error("SOFTWARE BUG: trying to read a SAM/BAM record prior to reading the header."));
return(false);
}
// Check to see if a new region has been set. If so, determine the
// chunks for that region.
if(myNewSection)
{
if(!processNewSection(header))
{
// Failed processing a new section. Could be an
// order issue like the file not being open or the
// indexed file not having been read.
// processNewSection sets myStatus with the failure reason.
return(false);
}
}
// Read until a record is not successfully read or there are no more
// requested records.
while(myStatus == SamStatus::SUCCESS)
{
record.setReference(myRefPtr);
record.setSequenceTranslation(myReadTranslation);
// If reading by index, this method will setup to ensure it is in
// the correct position for the next record (if not already there).
// Sets myStatus if it could not move to a good section.
// Just returns true if it is not setup to read by index.
if(!ensureIndexedReadPosition())
{
// Either there are no more records in the section
// or it failed to move to the right section, so there
// is nothing more to read, stop looping.
break;
}
// File is open for reading and the header has been read, so read the
// next record.
myInterfacePtr->readRecord(myFilePtr, header, record, myStatus);
if(myStatus != SamStatus::SUCCESS)
{
// Failed to read the record, so break out of the loop.
break;
}
// Successfully read a record, so check if we should filter it.
// First check if it is out of the section. Returns true
// if not reading by sections, returns false if the record
// is outside of the section. Sets status to NO_MORE_RECS if
// there is nothing left ot read in the section.
if(!checkRecordInSection(record))
{
// The record is not in the section.
// The while loop will detect if NO_MORE_RECS was set.
continue;
}
// Check the flag for required/excluded flags.
uint16_t flag = record.getFlag();
if((flag & myRequiredFlags) != myRequiredFlags)
{
// The record does not conatain all required flags, so
// continue looking.
continue;
}
if((flag & myExcludedFlags) != 0)
{
// The record contains an excluded flag, so continue looking.
continue;
}
//increment the record count.
myRecordCount++;
if(myStatistics != NULL)
{
// Statistics should be updated.
myStatistics->updateStatistics(record);
}
// Successfully read the record, so check the sort order.
if(!validateSortOrder(record, header))
{
// ValidateSortOrder sets the status on a failure.
return(false);
}
return(true);
} // End while loop that checks if a desired record is found or failure.
// Return true if a record was found.
return(myStatus == SamStatus::SUCCESS);
}
SamFile::validateSortOrder
bool validateSortOrder(SamRecord &record, SamFileHeader &header)
Validate that the record is sorted compared to the previously read record if there is one,...
Definition SamFile.cpp:1019
SamRecord::getFlag
uint16_t getFlag()
Get the flag (FLAG).
Definition SamRecord.cpp:1384

References StatGenStatus::FAIL_ORDER, SamRecord::getFlag(), myHasHeader, myIsOpenForRead, myRecordCount, myStatistics, myStatus, SamRecord::setReference(), SamRecord::setSequenceTranslation(), StatGenStatus::setStatus(), StatGenStatus::SUCCESS, and validateSortOrder().

Referenced by Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile().

## resetFile()

void SamFile::resetFile | ( |  | ) |

protected

Resets the file prepping for a new file.

Definition at line 966 of file SamFile.cpp.

{
// Close the file.
if (myFilePtr != NULL)
{
// If we already have an open file, close it.
ifclose(myFilePtr);
myFilePtr = NULL;
}
if(myInterfacePtr != NULL)
{
delete myInterfacePtr;
myInterfacePtr = NULL;
}
myIsOpenForRead = false;
myIsOpenForWrite = false;
myHasHeader = false;
mySortedType = UNSORTED;
myPrevReadName.Clear();
myPrevCoord = -1;
myPrevRefID = 0;
myRecordCount = 0;
myStatus = SamStatus::SUCCESS;
// Reset indexed bam values.
myIsBamOpenForRead = false;
myRefID = BamIndex::REF_ID_ALL;
myStartPos = -1;
myEndPos = -1;
myNewSection = false;
myOverlapSection = true;
myCurrentChunkEnd = 0;
myChunksToRead.clear();
if(myBamIndex != NULL)
{
delete myBamIndex;
myBamIndex = NULL;
}
// If statistics are being generated, reset them.
if(myStatistics != NULL)
{
myStatistics->reset();
}
myRefName.clear();
}
ifclose
int ifclose(IFILE &file)
Close the file.
Definition InputFile.h:580
SamFile::myPrevCoord
int32_t myPrevCoord
Previous values used for checking if the file is sorted.
Definition SamFile.h:409

References ifclose(), myHasHeader, myIsBamOpenForRead, myIsOpenForRead, myIsOpenForWrite, myPrevCoord, myRecordCount, myStatistics, myStatus, BamIndex::REF_ID_ALL, StatGenStatus::SUCCESS, and UNSORTED.

Referenced by SamFile(), SamFile(), ~SamFile(), Close(), OpenForRead(), and OpenForWrite().

## setAttemptRecovery()

void SamFile::setAttemptRecovery | ( | bool | flag = `false` | ) |

inline

Definition at line 451 of file SamFile.h.

{
myAttemptRecovery = flag;
}

## SetReadFlags()

void SamFile::SetReadFlags | ( | uint16_t | requiredFlags,
|  | uint16_t | excludedFlags
| ) |  |

Specify which reads should be returned by ReadRecord.

Reads will only be returned by ReadRecord that contain the specified required flags and that do not contain any of the specified excluded flags. ReadRecord will continue to read from the file until a record that complies with these flag settings is found or until the end of the file/region.

Parameters

  requiredFlags | flags that are required to be in records returned by ReadRecord (set to 0x0 if there are no required flags).
  excludedFlags | flags that are required to not be in records returned by ReadRecord (set to 0x0 if there are no excluded flags).

Definition at line 794 of file SamFile.cpp.

{
myRequiredFlags = requiredFlags;
myExcludedFlags = excludedFlags;
}

## SetReadSection() [1/4]

bool SamFile::SetReadSection | ( | const char * | refName | ) |

Sets which reference name of the BAM file should be read.

The records for that reference name will be retrieved on each ReadRecord call. Specify "" or "*" to read records not associated with a reference. When all records have been retrieved for the specified reference name, ReadRecord will return failure until a new read section is set. Must be called only after the file has been opened for reading. Sorting validation is reset everytime SetReadPosition is called since it can jump around in the file.

Parameters

  refName | the reference name of the records to read from the file.

Returns
  true = success; false = failure.

Definition at line 705 of file SamFile.cpp.

{
// No start/end specified, so set back to default -1.
return(SetReadSection(refName, -1, -1));
}
SamFile::SetReadSection
bool SetReadSection(int32_t refID)
Sets which reference id (index into the BAM list of reference information) of the BAM file should be ...
Definition SamFile.cpp:696

References SetReadSection().

## SetReadSection() [2/4]

bool SamFile::SetReadSection | ( | const char * | refName,
|  | int32_t | start,
|  | int32_t | end,
|  | bool | overlap = `true`
| ) |  |

Sets which reference name & start/end positions of the BAM file should be read.

The records for this reference name & positions will be retrieved on each ReadRecord call. Specify "" or "*" to indicate reads with no reference. When all records have been retrieved for the specified section, ReadRecord will return failure until a new read section is set. Must be called only after the file has been opened for reading. Sorting validation is reset everytime SetReadSection is called since it can jump around in the file.

Parameters

  refName | the reference name of the records to read from the file.
  start | inclusive 0-based start position of records that should be read for this refID.
  end | exclusive 0-based end position of records that should be read for this refID.
  overlap | When true (default), return reads that just overlap the region; when false, only return reads that fall completely within the region

Returns
  true = success; false = failure.

Definition at line 749 of file SamFile.cpp.

{
// If there is not a BAM file open for reading, return failure.
// Opening a new file clears the read section, so it must be
// set after the file is opened.
if(!myIsBamOpenForRead)
{
// There is not a BAM file open for reading.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot set section since there is no bam file open");
return(false);
}
myNewSection = true;
myOverlapSection = overlap;
myStartPos = start;
myEndPos = end;
if((strcmp(refName, "") == 0) || (strcmp(refName, "*") == 0))
{
// No Reference name specified, so read just the "-1" entries.
myRefID = BamIndex::REF_ID_UNMAPPED;
}
else
{
// save the reference name and revert the reference ID to unknown
// so it will be calculated later.
myRefName = refName;
myRefID = BamIndex::REF_ID_ALL;
}
myChunksToRead.clear();
// Reset the end of the current chunk. We are resetting our read, so
// we no longer have a "current chunk" that we are reading.
myCurrentChunkEnd = 0;
myStatus = SamStatus::SUCCESS;
// Reset the sort order criteria since we moved around in the file.
myPrevCoord = -1;
myPrevRefID = 0;
myPrevReadName.Clear();
return(true);
}

References StatGenStatus::FAIL_ORDER, myIsBamOpenForRead, myPrevCoord, myStatus, BamIndex::REF_ID_ALL, BamIndex::REF_ID_UNMAPPED, StatGenStatus::setStatus(), and StatGenStatus::SUCCESS.

## SetReadSection() [3/4]

bool SamFile::SetReadSection | ( | int32_t | refID | ) |

Sets which reference id (index into the BAM list of reference information) of the BAM file should be read.

The records for that reference id will be retrieved on each ReadRecord call.
Reference ids start at 0, and -1 indicates reads with no reference. When all records have been retrieved for the specified reference id, ReadRecord will return failure until a new read section is set. Must be called only after the file has been opened for reading. Sorting validation is reset everytime SetReadPosition is called since it can jump around in the file.

Parameters

  refID | the reference ID of the records to read from the file.

Returns
  true = success; false = failure.

Definition at line 696 of file SamFile.cpp.

{
// No start/end specified, so set back to default -1.
return(SetReadSection(refID, -1, -1));
}

References SetReadSection().

Referenced by SetReadSection(), and SetReadSection().

## SetReadSection() [4/4]

bool SamFile::SetReadSection | ( | int32_t | refID,
|  | int32_t | start,
|  | int32_t | end,
|  | bool | overlap = `true`
| ) |  |

Sets which reference id (index into the BAM list of reference information) & start/end positions of the BAM file should be read.

The records for that reference id and positions will be retrieved on each ReadRecord call. Reference ids start at 0, and -1 indicates reads with no reference. When all records have been retrieved for the specified reference id, ReadRecord will return failure until a new read section is set. Must be called only after the file has been opened for reading. Sorting validation is reset everytime SetReadPosition is called since it can jump around in the file.

Parameters

  refID | the reference ID of the records to read from the file.
  start | inclusive 0-based start position of records that should be read for this refID.
  end | exclusive 0-based end position of records that should be read for this refID.
  overlap | When true (default), return reads that just overlap the region; when false, only return reads that fall completely within the region

Returns
  true = success; false = failure.

Definition at line 713 of file SamFile.cpp.

{
// If there is not a BAM file open for reading, return failure.
// Opening a new file clears the read section, so it must be
// set after the file is opened.
if(!myIsBamOpenForRead)
{
// There is not a BAM file open for reading.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot set section since there is no bam file open");
return(false);
}
myNewSection = true;
myOverlapSection = overlap;
myStartPos = start;
myEndPos = end;
myRefID = refID;
myRefName.clear();
myChunksToRead.clear();
// Reset the end of the current chunk. We are resetting our read, so
// we no longer have a "current chunk" that we are reading.
myCurrentChunkEnd = 0;
myStatus = SamStatus::SUCCESS;
// Reset the sort order criteria since we moved around in the file.
myPrevCoord = -1;
myPrevRefID = 0;
myPrevReadName.Clear();
return(true);
}

References StatGenStatus::FAIL_ORDER, myIsBamOpenForRead, myPrevCoord, myStatus, StatGenStatus::setStatus(), and StatGenStatus::SUCCESS.

## SetReadSequenceTranslation()

void SamFile::SetReadSequenceTranslation | ( | SamRecord::SequenceTranslation | translation | ) |

Set the type of sequence translation to use when reading the sequence.

Passed down to the SamRecord when it is read.
The default type (if this method is never called) is NONE (the sequence is left as-is).

Parameters

  translation | type of sequence translation to use.

Definition at line 387 of file SamFile.cpp.

{
myReadTranslation = translation;
}

## SetReference()

void SamFile::SetReference | ( | GenomeSequence * | reference | ) |

Sets the reference to the specified genome sequence object.

Parameters

  reference | pointer to the GenomeSequence object.

Definition at line 380 of file SamFile.cpp.

{
myRefPtr = reference;
}

Referenced by Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile().

## setSortedValidation()

void SamFile::setSortedValidation | ( | SortedType | sortType | ) |

Set the flag to validate that the file is sorted as it is read/written.

Must be called after the file has been opened. Sorting validation is reset everytime SetReadPosition is called since it can jump around in the file.

Parameters

  sortType | specifies the type of sort to be checked for.

Definition at line 682 of file SamFile.cpp.

{
mySortedType = sortType;
}

Referenced by Pileup< PILEUP_TYPE, FUNC_CLASS >::processFile().

## SetWriteSequenceTranslation()

void SamFile::SetWriteSequenceTranslation | ( | SamRecord::SequenceTranslation | translation | ) |

Set the type of sequence translation to use when writing the sequence.

Passed down to the SamRecord when it is written. The default type (if this method is never called) is NONE (the sequence is left as-is).

Parameters

  translation | type of sequence translation to use.

Definition at line 394 of file SamFile.cpp.

{
myWriteTranslation = translation;
}

## validateSortOrder()

bool SamFile::validateSortOrder | ( | SamRecord & | record,
|  | SamFileHeader & | header
| ) |  |

protected

Validate that the record is sorted compared to the previously read record if there is one, according to the specified sort order.

If the sort order is UNSORTED, true is returned. Sorting validation is reset everytime SetReadPosition is called since it can jump around in the file.

Definition at line 1019 of file SamFile.cpp.

{
if(myRefPtr != NULL)
{
record.setReference(myRefPtr);
}
record.setSequenceTranslation(myReadTranslation);
bool status = false;
if(mySortedType == UNSORTED)
{
// Unsorted, so nothing to validate, just return true.
status = true;
}
else
{
// Check to see if mySortedType is based on the header.
if(mySortedType == FLAG)
{
// Determine the sorted type from what was read out of the header.
mySortedType = getSortOrderFromHeader(header);
}
if(mySortedType == QUERY_NAME)
{
// Validate that it is sorted by query name.
// Get the query name from the record.
const char* readName = record.getReadName();
// Check if it is sorted either in samtools way or picard's way.
if((myPrevReadName.Compare(readName) > 0) &&
(strcmp(myPrevReadName.c_str(), readName) > 0))
{
// return false.
String errorMessage = "ERROR: File is not sorted by read name at record ";
errorMessage += myRecordCount;
errorMessage += "\n\tPrevious record was ";
errorMessage += myPrevReadName;
errorMessage += ", but this record is ";
errorMessage += readName;
myStatus.setStatus(SamStatus::INVALID_SORT,
errorMessage.c_str());
status = false;
}
else
{
myPrevReadName = readName;
status = true;
}
}
else
{
// Validate that it is sorted by COORDINATES.
// Get the leftmost coordinate and the reference index.
int32_t refID = record.getReferenceID();
int32_t coord = record.get0BasedPosition();
// The unmapped reference id is at the end of a sorted file.
if(refID == BamIndex::REF_ID_UNMAPPED)
{
// A new reference ID that is for the unmapped reads
// is always valid.
status = true;
myPrevRefID = refID;
myPrevCoord = coord;
}
else if(myPrevRefID == BamIndex::REF_ID_UNMAPPED)
{
// Previous reference ID was for unmapped reads, but the
// current one is not, so this is not sorted.
String errorMessage = "ERROR: File is not coordinate sorted at record ";
errorMessage += myRecordCount;
errorMessage += "\n\tPrevious record was unmapped, but this record is ";
errorMessage += header.getReferenceLabel(refID) + ":" + coord;
myStatus.setStatus(SamStatus::INVALID_SORT,
errorMessage.c_str());
status = false;
}
else if(refID < myPrevRefID)
{
// Current reference id is less than the previous one,
//meaning that it is not sorted.
String errorMessage = "ERROR: File is not coordinate sorted at record ";
errorMessage += myRecordCount;
errorMessage += "\n\tPrevious record was ";
errorMessage += header.getReferenceLabel(myPrevRefID) + ":" + myPrevCoord;
errorMessage += ", but this record is ";
errorMessage += header.getReferenceLabel(refID) + ":" + coord;
myStatus.setStatus(SamStatus::INVALID_SORT,
errorMessage.c_str());
status = false;
}
else
{
// The reference IDs are in the correct order.
if(refID > myPrevRefID)
{
// New reference id, so set the previous coordinate to -1
myPrevCoord = -1;
}
// Check the coordinates.
if(coord < myPrevCoord)
{
// New Coord is less than the previous position.
String errorMessage = "ERROR: File is not coordinate sorted at record ";
errorMessage += myRecordCount;
errorMessage += "\n\tPreviousRecord was ";
errorMessage += header.getReferenceLabel(myPrevRefID) + ":" + myPrevCoord;
errorMessage += ", but this record is ";
errorMessage += header.getReferenceLabel(refID) + ":" + coord;
myStatus.setStatus(SamStatus::INVALID_SORT,
errorMessage.c_str());
status = false;
}
else
{
myPrevRefID = refID;
myPrevCoord = coord;
status = true;
}
}
}
}
return(status);
}
SamFileHeader::getReferenceLabel
const String & getReferenceLabel(int id) const
Return the reference name (chromosome) for the specified reference id.
Definition SamFileHeader.cpp:158
SamRecord::getReadName
const char * getReadName()
Returns the SAM formatted Read Name (QNAME).
Definition SamRecord.cpp:1542
StatGenStatus::INVALID_SORT
@ INVALID_SORT
record is invalid due to it not being sorted.
Definition StatGenStatus.h:43

References FLAG, SamRecord::get0BasedPosition(), SamRecord::getReadName(), SamRecord::getReferenceID(), SamFileHeader::getReferenceLabel(), StatGenStatus::INVALID_SORT, myPrevCoord, myRecordCount, myStatus, QUERY_NAME, BamIndex::REF_ID_UNMAPPED, SamRecord::setReference(), SamRecord::setSequenceTranslation(), StatGenStatus::setStatus(), and UNSORTED.

Referenced by ReadRecord(), and WriteRecord().

## WriteHeader()

bool SamFile::WriteHeader | ( | SamFileHeader & | header | ) |

Writes the specified header into the file.

Returns
  true = success; false = failure.

Definition at line 480 of file SamFile.cpp.

{
myStatus = SamStatus::SUCCESS;
if(myIsOpenForWrite == false)
{
// File is not open for write
// -OR-
// The header has already been written.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot write header since the file is not open for writing");
return(false);
}
if(myHasHeader == true)
{
// The header has already been written.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot write header since it has already been written");
return(false);
}
if(myInterfacePtr->writeHeader(myFilePtr, header, myStatus))
{
// The header has now been successfully written.
myHasHeader = true;
return(true);
}
// return the status.
return(false);
}

References StatGenStatus::FAIL_ORDER, myHasHeader, myIsOpenForWrite, myStatus, StatGenStatus::setStatus(), and StatGenStatus::SUCCESS.

Referenced by OpenForWrite().

## WriteRecord()

bool SamFile::WriteRecord | ( | SamFileHeader & | header,
|  | SamRecord & | record
| ) |  |

Writes the specified record into the file.

Validates that the record is sorted according to the value set by setSortedValidation. No sorting validation is done if specified to be unsorted, or setSortedValidation was never called. Returns false and does not write the record if the record was not properly sorted.

Returns
  true = success; false = failure.

Definition at line 632 of file SamFile.cpp.

{
if(myIsOpenForWrite == false)
{
// File is not open for writing
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot write record since the file is not open for writing");
return(false);
}
if(myHasHeader == false)
{
// The header has not yet been written.
myStatus.setStatus(SamStatus::FAIL_ORDER,
"Cannot write record since the header has not been written");
return(false);
}
// Before trying to write the record, validate the sort order.
if(!validateSortOrder(record, header))
{
// Not sorted like it is supposed to be, do not write the record
myStatus.setStatus(SamStatus::INVALID_SORT,
"Cannot write the record since the file is not properly sorted.");
return(false);
}
if(myRefPtr != NULL)
{
record.setReference(myRefPtr);
}
// File is open for writing and the header has been written, so write the
// record.
myStatus = myInterfacePtr->writeRecord(myFilePtr, header, record,
myWriteTranslation);
if(myStatus == SamStatus::SUCCESS)
{
// A record was successfully written, so increment the record count.
myRecordCount++;
return(true);
}
return(false);
}

References StatGenStatus::FAIL_ORDER, StatGenStatus::INVALID_SORT, myHasHeader, myIsOpenForWrite, myRecordCount, myStatus, SamRecord::setReference(), StatGenStatus::setStatus(), StatGenStatus::SUCCESS, and validateSortOrder().

Referenced by SamCoordOutput::flush().

## Member Data Documentation

## myBamIndex

BamIndex* SamFile::myBamIndex

protected

Definition at line 433 of file SamFile.h.

## myChunksToRead

SortedChunkList SamFile::myChunksToRead

protected

Definition at line 432 of file SamFile.h.

## myCurrentChunkEnd

uint64_t SamFile::myCurrentChunkEnd

protected

Definition at line 431 of file SamFile.h.

## myEndPos

int32_t SamFile::myEndPos

protected

Definition at line 430 of file SamFile.h.

## myFilePtr

IFILE SamFile::myFilePtr

protected

Definition at line 395 of file SamFile.h.

## myHasHeader

bool SamFile::myHasHeader

protected

Flag to indicate if a header has been read/written - required before being able to read/write a record.

Definition at line 404 of file SamFile.h.

Referenced by ReadHeader(), ReadRecord(), resetFile(), WriteHeader(), and WriteRecord().

## myInterfacePtr

GenericSamInterface* SamFile::myInterfacePtr

protected

Definition at line 396 of file SamFile.h.

## myIsBamOpenForRead

bool SamFile::myIsBamOpenForRead

protected

Values for reading Sorted BAM files via the index.

Definition at line 423 of file SamFile.h.

Referenced by OpenForRead(), resetFile(), SetReadSection(), and SetReadSection().

## myIsOpenForRead

bool SamFile::myIsOpenForRead

protected

Flag to indicate if a file is open for reading.

Definition at line 399 of file SamFile.h.

Referenced by IsEOF(), OpenForRead(), ReadHeader(), ReadRecord(), and resetFile().

## myIsOpenForWrite

bool SamFile::myIsOpenForWrite

protected

Flag to indicate if a file is open for writing.

Definition at line 401 of file SamFile.h.

Referenced by OpenForWrite(), resetFile(), WriteHeader(), and WriteRecord().

## myNewSection

bool SamFile::myNewSection

protected

Definition at line 424 of file SamFile.h.

## myOverlapSection

bool SamFile::myOverlapSection

protected

Definition at line 427 of file SamFile.h.

## myPrevCoord

int32_t SamFile::myPrevCoord

protected

Previous values used for checking if the file is sorted.

Definition at line 409 of file SamFile.h.

Referenced by resetFile(), SetReadSection(), SetReadSection(), and validateSortOrder().

## myPrevReadName

String SamFile::myPrevReadName

protected

Definition at line 411 of file SamFile.h.

## myPrevRefID

int32_t SamFile::myPrevRefID

protected

Definition at line 410 of file SamFile.h.

## myReadTranslation

SamRecord::SequenceTranslation SamFile::myReadTranslation

protected

Definition at line 436 of file SamFile.h.

## myRecordCount

uint32_t SamFile::myRecordCount

protected

Keep a count of the number of records that have been read/written so far.

Definition at line 414 of file SamFile.h.

Referenced by GetCurrentRecordCount(), ReadRecord(), resetFile(), validateSortOrder(), and WriteRecord().

## myRefID

int32_t SamFile::myRefID

protected

Definition at line 428 of file SamFile.h.

## myRefName

std::string SamFile::myRefName

protected

Definition at line 439 of file SamFile.h.

## myRefPtr

GenomeSequence* SamFile::myRefPtr

protected

Definition at line 435 of file SamFile.h.

## mySortedType

SortedType SamFile::mySortedType

protected

Definition at line 406 of file SamFile.h.

## myStartPos

int32_t SamFile::myStartPos

protected

Definition at line 429 of file SamFile.h.

## myStatistics

SamStatistics* SamFile::myStatistics

protected

Pointer to the statistics for this file.

Definition at line 417 of file SamFile.h.

Referenced by ~SamFile(), GenerateStatistics(), PrintStatistics(), ReadRecord(), and resetFile().

## myStatus

SamStatus SamFile::myStatus

protected

The status of the last SamFile command.

Definition at line 420 of file SamFile.h.

Referenced by getNumMappedReadsFromIndex(), getNumMappedReadsFromIndex(), getNumUnMappedReadsFromIndex(), getNumUnMappedReadsFromIndex(), GetStatus(), GetStatusMessage(), OpenForRead(), OpenForWrite(), ReadBamIndex(), ReadBamIndex(), ReadHeader(), ReadRecord(), resetFile(), SetReadSection(), SetReadSection(), validateSortOrder(), WriteHeader(), and WriteRecord().

## myWriteTranslation

SamRecord::SequenceTranslation SamFile::myWriteTranslation

protected

Definition at line 437 of file SamFile.h.

The documentation for this class was generated from the following files:

- bam/SamFile.h
- bam/SamFile.cpp