bool NewChromSweep::next(RecordKeyVector &retList) {
retList.clearVector();
//make sure the first read of the query file is tested for chrom sort order.
bool needTestSortOrder = false;
if (_currQueryRec != NULL) {
_queryFRM->deleteRecord(_currQueryRec);
} else {
needTestSortOrder = true;
}
if (!nextRecord(true)) return false; // query EOF hit
retList.setKey(_currQueryRec);
if (needTestSortOrder) testChromOrder(_currQueryRec);
if (allCurrDBrecsNull() && allCachesEmpty() && !_runToQueryEnd) {
_testLastQueryRec = true;
return false;
}
_currQueryChromName = _currQueryRec->getChrName();
masterScan(retList);
if (_context->getSortOutput()) {
retList.sortVector();
}
_prevQueryChromName = _currQueryChromName;
return true;
}
int BlockMgr::findBlockedOverlaps(RecordKeyVector &keyList, RecordKeyVector &hitList, RecordKeyVector &resultList)
{
bool deleteKeyBlocks = false;
if (keyList.empty()) {
//get all the blocks for the query record, put them in it's list.
getBlocks(keyList, deleteKeyBlocks);
}
_overlapBases.clear();
int keyBlocksSumLength = getTotalBlockLength(keyList);
//Loop through every database record the query intersected with
for (RecordKeyVector::const_iterator_type hitListIter = hitList.begin(); hitListIter != hitList.end(); hitListIter = hitList.next()) {
RecordKeyVector hitBlocks(*hitListIter);
bool deleteHitBlocks = false;
getBlocks(hitBlocks, deleteHitBlocks); //get all blocks for the hit record.
int hitBlockSumLength = getTotalBlockLength(hitBlocks); //get total length of the bocks for the hitRecord.
int totalHitOverlap = 0;
bool hitHasOverlap = false;
//loop through every block of the database record.
for (RecordKeyVector::const_iterator_type hitBlockIter = hitBlocks.begin(); hitBlockIter != hitBlocks.end(); hitBlockIter = hitBlocks.next()) {
//loop through every block of the query record.
for (RecordKeyVector::const_iterator_type keyListIter = keyList.begin(); keyListIter != keyList.end(); keyListIter = keyList.next()) {
const Record *keyBlock = *keyListIter;
const Record *hitBlock = *hitBlockIter;
int maxStart = max(keyBlock->getStartPos(), hitBlock->getStartPos());
int minEnd = min(keyBlock->getEndPos(), hitBlock->getEndPos());
int overlap = minEnd - maxStart;
if (overlap > 0) {
hitHasOverlap = true;
totalHitOverlap += overlap;
}
}
}
if (hitHasOverlap) {
if ((float) totalHitOverlap / (float)keyBlocksSumLength >= _overlapFraction) {
if (_hasReciprocal &&
((float)totalHitOverlap / (float)hitBlockSumLength >= _overlapFraction)) {
_overlapBases.push_back(totalHitOverlap);
resultList.push_back(*hitListIter);
} else if (!_hasReciprocal) {
_overlapBases.push_back(totalHitOverlap);
resultList.push_back(*hitListIter);
}
}
}
if (deleteHitBlocks) {
deleteBlocks(hitBlocks);
}
}
if (deleteKeyBlocks) {
deleteBlocks(keyList);
}
resultList.setKey(keyList.getKey());
return (int)resultList.size();
}
bool IntersectFile::nextUnsortedFind(RecordKeyVector &hits)
{
while (!_queryFRM->eof()) {
Record *queryRecord = _queryFRM->getNextRecord();
if (queryRecord == NULL) {
continue;
} else {
_context->testNameConventions(queryRecord);
hits.setKey(queryRecord);
_binTree->getHits(queryRecord, hits);
return true;
}
}
return false;
}
bool SpacingFile::findNext(RecordKeyVector &hits)
{
while (!_inputFile->eof()) {
_currRec = _inputFile->getNextRecord();
// no more records
if (_currRec == NULL) {
continue;
}
// first record in file.
if (_prevRec == NULL) {
_distance.append(".");
}
// the meat of the file
else {
// _currRecent and _prevRecious records are on the same chromosome.
if (_currRec->getChrName() == _prevRec->getChrName())
{
// do _currRec and _prevRec overlap?
if (_currRec->sameChromIntersects(_prevRec, false, false, 1E-9, 1E-9, false, false))
_distance.append("0");
else
{
int distance = _currRec->getStartPos() - _prevRec->getEndPos();
ostringstream s;
s << distance;
_distance.append(s.str());
}
}
// we have changed chromosomes
else if (_currRec->getChrName() != _prevRec->getChrName())
{
_distance.append(".");
}
}
hits.setKey(_currRec);
return true;
}
return false;
}
bool GroupBy::findNext(RecordKeyVector &hits)
{
//get one record.
if (_prevRecord == NULL) {
return false;
}
assignPrevFields();
hits.setKey(_prevRecord);
hits.push_back(_prevRecord); //key should also be part of group for calculations
while (1) {
const Record *newRecord = getNextRecord();
if (newRecord == NULL) {
_prevRecord = NULL;
break;
} else if (canGroup(newRecord)) {
hits.push_back(newRecord);
} else {
_prevRecord = newRecord;
break;
}
}
return true;
}
void FileRecordMergeMgr::deleteMergedRecord(RecordKeyVector &recList)
{
deleteAllMergedItemsButKey(recList);
deleteRecord(recList.getKey());
recList.setKey(NULL);
}
