void DefaultGappedBottomSegmentIterator::toRightNextUngapped(
BottomSegmentIteratorConstPtr bs) const
{
while (bs->hasChild(_childIndex) == false &&
bs->getLength() <= _gapThreshold)
{
if ((!bs->getReversed() && bs->getBottomSegment()->isLast()) ||
(bs->getReversed() && bs->getBottomSegment()->isFirst()))
{
break;
}
bs->toRight();
}
}
//////////////////////////////////////////////////////////////////////////////
// INTERNAL METHODS
//////////////////////////////////////////////////////////////////////////////
bool DefaultGappedBottomSegmentIterator::compatible(
BottomSegmentIteratorConstPtr left,
BottomSegmentIteratorConstPtr right) const
{
assert(left->hasChild(_childIndex) && right->hasChild(_childIndex));
assert(left->equals(right) == false);
_leftChild->toChild(left, _childIndex);
_rightChild->toChild(right, _childIndex);
if (_leftChild->getTopSegment()->getParentReversed() !=
_rightChild->getTopSegment()->getParentReversed())
{
return false;
}
if (_leftChild->hasNextParalogy() != _rightChild->hasNextParalogy())
{
return false;
}
if ((!_leftChild->getReversed() &&
_leftChild->leftOf(_rightChild->getStartPosition()) == false) ||
(_leftChild->getReversed() &&
_leftChild->rightOf(_rightChild->getStartPosition()) == false))
{
return false;
}
if (left->getBottomSegment()->getSequence() !=
right->getBottomSegment()->getSequence() ||
_leftChild->getTopSegment()->getSequence() !=
_rightChild->getTopSegment()->getSequence())
{
return false;
}
while (true)
{
assert(_leftChild->isLast() == false);
_leftChild->toRight();
if (_leftChild->hasParent() == true ||
_leftChild->getLength() > _gapThreshold)
{
if (_leftChild->equals(_rightChild))
{
break;
}
else
{
return false;
}
}
}
_leftChild->toChild(left, _childIndex);
_rightChild->toChild(right, _childIndex);
if (_leftChild->hasNextParalogy() == true)
{
_leftDup->copy(_leftChild);
_leftDup->toNextParalogy();
_rightDup->copy(_rightChild);
_rightDup->toNextParalogy();
if ((_leftDup->getReversed() == false &&
_leftDup->leftOf(_rightDup->getStartPosition()) == false) ||
(_leftDup->getReversed() == true &&
_rightDup->leftOf(_leftDup->getStartPosition()) == false))
{
return false;
}
if (_leftDup->getTopSegment()->getSequence() !=
_rightDup->getTopSegment()->getSequence())
{
return false;
}
while (true)
{
assert(_leftDup->isLast() == false);
_leftDup->toRight();
if (_leftDup->hasParent() == true ||
_leftDup->getLength() > _gapThreshold)
{
if (_leftDup->equals(_rightDup))
{
break;
}
else
{
return false;
}
}
}
}
return true;
}
// quickly count subsitutions without loading rearrangement machinery.
// used for benchmarks for basic file scanning... and not much else since
// the interface is still a bit wonky.
void SummarizeMutations::substitutionAnalysis(const Genome* genome,
MutationsStats& stats)
{
assert(stats._subs == 0);
if (genome->getNumChildren() == 0 || genome->getNumBottomSegments() == 0 ||
(_targetSet && _targetSet->find(genome->getName()) == _targetSet->end()))
{
return;
}
const Genome* parent = genome->getParent();
string pname = parent != NULL ? parent->getName() : string();
StrPair branchName(genome->getName(), pname);
BottomSegmentIteratorConstPtr bottom = genome->getBottomSegmentIterator();
TopSegmentIteratorConstPtr top = genome->getChild(0)->getTopSegmentIterator();
string gString, cString;
hal_size_t n = genome->getNumBottomSegments();
vector<hal_size_t> children;
hal_size_t m = genome->getNumChildren();
for (hal_size_t i = 0; i < m; ++i)
{
string cName = genome->getChild(i)->getName();
if (!_targetSet ||
(_targetSet && _targetSet->find(cName) != _targetSet->end()))
{
children.push_back(i);
}
}
if (children.empty())
{
return;
}
for (hal_size_t i = 0; i < n; ++i)
{
bool readString = false;
for (size_t j = 0; j < children.size(); ++j)
{
if (bottom->hasChild(children[j]))
{
if (readString == false)
{
bottom->getString(gString);
readString = true;
}
top->toChild(bottom, children[j]);
top->getString(cString);
assert(gString.length() == cString.length());
for (hal_size_t k = 0; k < gString.length(); ++k)
{
if (isSubstitution(gString[k], cString[k]))
{
++stats._subs;
}
}
}
}
bottom->toRight();
}
}
