1 // ***************************************************************************
2 // BamRandomAccessController_p.cpp (c) 2011 Derek Barnett
3 // Marth Lab, Department of Biology, Boston College
4 // All rights reserved.
5 // ---------------------------------------------------------------------------
6 // Last modified: 5 April 2011(DB)
7 // ---------------------------------------------------------------------------
8 // Manages random access operations in a BAM file
9 // **************************************************************************
11 #include <api/BamIndex.h>
12 #include <api/internal/BamRandomAccessController_p.h>
13 #include <api/internal/BamReader_p.h>
14 #include <api/internal/BamIndexFactory_p.h>
15 using namespace BamTools;
16 using namespace BamTools::Internal;
21 BamRandomAccessController::BamRandomAccessController(void)
23 , m_indexCacheMode(BamIndex::LimitedIndexCaching)
24 , m_hasAlignmentsInRegion(true)
27 BamRandomAccessController::~BamRandomAccessController(void) {
31 void BamRandomAccessController::AdjustRegion(const int& referenceCount) {
33 // skip if no index available
37 // see if any references in region have alignments
38 m_hasAlignmentsInRegion = false;
39 int currentId = m_region.LeftRefID;
40 const int rightBoundRefId = ( m_region.isRightBoundSpecified() ? m_region.RightRefID : referenceCount - 1 );
41 while ( currentId <= rightBoundRefId ) {
42 m_hasAlignmentsInRegion = m_index->HasAlignments(currentId);
43 if ( m_hasAlignmentsInRegion ) break;
47 // if no data found on any reference in region
48 if ( !m_hasAlignmentsInRegion )
51 // if left bound of desired region had no data, use first reference that had data
52 // otherwise, leave requested region as-is
53 if ( currentId != m_region.LeftRefID ) {
54 m_region.LeftRefID = currentId;
55 m_region.LeftPosition = 0;
59 // returns alignments' "RegionState": { Before|Overlaps|After } current region
60 BamRandomAccessController::RegionState
61 BamRandomAccessController::AlignmentState(const BamAlignment& alignment) const {
63 // if region has no left bound at all
64 if ( !m_region.isLeftBoundSpecified() )
65 return OverlapsRegion;
67 // handle unmapped reads - return AFTER region to halt processing
68 if ( alignment.RefID == -1 )
71 // if alignment is on any reference before left bound reference
72 if ( alignment.RefID < m_region.LeftRefID )
75 // if alignment is on left bound reference
76 else if ( alignment.RefID == m_region.LeftRefID ) {
78 // if alignment starts at or after left bound position
79 if ( alignment.Position >= m_region.LeftPosition) {
81 if ( m_region.isRightBoundSpecified() && // right bound is specified AND
82 m_region.LeftRefID == m_region.RightRefID && // left & right bounds on same reference AND
83 alignment.Position > m_region.RightPosition ) // alignment starts after right bound position
86 // otherwise, alignment overlaps region
87 else return OverlapsRegion;
90 // alignment starts before left bound position
93 // if alignment overlaps left bound position
94 if ( alignment.GetEndPosition() >= m_region.LeftPosition )
95 return OverlapsRegion;
101 // otherwise alignment is on a reference after left bound reference
104 // if region has a right bound
105 if ( m_region.isRightBoundSpecified() ) {
107 // alignment is on any reference between boundaries
108 if ( alignment.RefID < m_region.RightRefID )
109 return OverlapsRegion;
111 // alignment is on any reference after right boundary
112 else if ( alignment.RefID > m_region.RightRefID )
115 // alignment is on right bound reference
118 // if alignment starts on or before right bound position
119 if ( alignment.Position <= m_region.RightPosition )
120 return OverlapsRegion;
126 // otherwise, alignment starts after left bound and there is no right bound
127 else return OverlapsRegion;
131 void BamRandomAccessController::Close(void) {
136 void BamRandomAccessController::ClearIndex(void) {
141 void BamRandomAccessController::ClearRegion(void) {
143 m_hasAlignmentsInRegion = true;
146 bool BamRandomAccessController::CreateIndex(BamReaderPrivate* reader,
147 const BamIndex::IndexType& type) {
149 // skip if reader is invalid
153 // create new index of requested type
154 BamIndex* newIndex = BamIndexFactory::CreateIndexOfType(type, reader);
155 if ( newIndex == 0 ) {
156 cerr << "BamRandomAccessController ERROR: could not create index of type " << type << endl;
160 // attempt to build index from current BamReader file
161 if ( !newIndex->Create() ) {
162 cerr << "BamRandomAccessController ERROR: could not create index for BAM file: "
163 << reader->Filename() << endl;
170 // set new index's cache mode & return success
171 newIndex->SetCacheMode(m_indexCacheMode);
175 bool BamRandomAccessController::HasIndex(void) const {
176 return ( m_index != 0 );
179 bool BamRandomAccessController::HasRegion(void) const {
180 return ( !m_region.isNull() );
183 bool BamRandomAccessController::IndexHasAlignmentsForReference(const int& refId) {
184 return m_index->HasAlignments(refId);
187 bool BamRandomAccessController::LocateIndex(BamReaderPrivate* reader,
188 const BamIndex::IndexType& preferredType)
190 // look up index filename, deferring to preferredType if possible
191 const string& indexFilename = BamIndexFactory::FindIndexFilename(reader->Filename(), preferredType);
193 // if no index file found (of any type)
194 if ( indexFilename.empty() ) {
195 cerr << "BamRandomAccessController WARNING: "
196 << "could not find index file for BAM: "
197 << reader->Filename() << endl;
201 // otherwise open & use index file that was found
202 return OpenIndex(indexFilename, reader);
205 bool BamRandomAccessController::OpenIndex(const string& indexFilename, BamReaderPrivate* reader) {
207 // attempt create new index of type based on filename
208 BamIndex* index = BamIndexFactory::CreateIndexFromFilename(indexFilename, reader);
210 cerr << "BamRandomAccessController ERROR: could not create index for file: " << indexFilename << endl;
215 index->SetCacheMode(m_indexCacheMode);
217 // attempt to load data from index file
218 if ( !index->Load(indexFilename) ) {
219 cerr << "BamRandomAccessController ERROR: could not load index data from file: " << indexFilename << endl;
223 // save new index & return success
228 bool BamRandomAccessController::RegionHasAlignments(void) const {
229 return m_hasAlignmentsInRegion;
232 void BamRandomAccessController::SetIndex(BamIndex* index) {
238 void BamRandomAccessController::SetIndexCacheMode(const BamIndex::IndexCacheMode& mode) {
239 m_indexCacheMode = mode;
241 m_index->SetCacheMode(mode);
244 bool BamRandomAccessController::SetRegion(BamReaderPrivate* reader,
245 const BamRegion& region,
246 const int& referenceCount)
251 // cannot jump when no index is available
255 // adjust region as necessary to reflect where data actually begins
256 AdjustRegion(referenceCount);
258 // if no data present, return true
259 // * Not an error, but future attempts to access alignments in this region will not return data
260 // Returning true is useful in a BamMultiReader setting where some BAM files may
261 // lack alignments in regions where other BAMs do have data.
262 if ( !m_hasAlignmentsInRegion )
265 // return success/failure of jump to specified region,
267 // * Index::Jump() is allowed to modify the m_hasAlignmentsInRegion flag
268 // This covers 'corner case' where a region is requested that lies beyond the last
269 // alignment on a reference. If this occurs, any subsequent calls to GetNextAlignment[Core]
270 // will not return data. BamMultiReader will still be able to successfully pull alignments
271 // from a region from multiple files even if one or more have no data.
272 return m_index->Jump(m_region, &m_hasAlignmentsInRegion);