//////////////////////////////////////////////////////////////////////////////
// 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;
}
void
GappedSegmentSimpleIteratorTest::checkCallBack(AlignmentConstPtr alignment)
{
const Genome* child = alignment->openGenome("child");
const Genome* parent = alignment->openGenome("parent");
GappedTopSegmentIteratorConstPtr gtsIt =
child->getGappedTopSegmentIterator(0, 9999999);
GappedBottomSegmentIteratorConstPtr gbsIt =
parent->getGappedBottomSegmentIterator(0, 0, 9999999);
GappedTopSegmentIteratorConstPtr gtsItRev =
child->getGappedTopSegmentIterator(0, 9999999);
gtsItRev->toReverse();
GappedBottomSegmentIteratorConstPtr gbsItRev =
parent->getGappedBottomSegmentIterator(0, 0, 9999999);
gbsItRev->toReverse();
for (size_t i = 0; i < child->getNumTopSegments(); ++i)
{
TopSegmentIteratorConstPtr tsIt = gtsIt->getLeft();
CuAssertTrue(_testCase, tsIt->equals(gtsIt->getRight()));
CuAssertTrue(_testCase,
(size_t)tsIt->getTopSegment()->getArrayIndex() == i);
gtsIt->toRight();
BottomSegmentIteratorConstPtr bsIt = gbsIt->getLeft();
CuAssertTrue(_testCase, bsIt->equals(gbsIt->getRight()));
CuAssertTrue(_testCase,
(size_t)bsIt->getBottomSegment()->getArrayIndex() == i);
gbsIt->toRight();
TopSegmentIteratorConstPtr tsItRev = gtsItRev->getLeft();
CuAssertTrue(_testCase, tsItRev->equals(gtsItRev->getRight()));
CuAssertTrue(_testCase,
(size_t)tsItRev->getTopSegment()->getArrayIndex() == i);
gtsItRev->toLeft();
BottomSegmentIteratorConstPtr bsItRev = gbsItRev->getLeft();
CuAssertTrue(_testCase, bsItRev->equals(gbsItRev->getRight()));
CuAssertTrue(_testCase,
(size_t)bsItRev->getBottomSegment()->getArrayIndex() == i);
gbsItRev->toLeft();
}
gtsIt = child->getGappedTopSegmentIterator(
child->getNumTopSegments() - 1, 9999999);
gbsIt = parent->getGappedBottomSegmentIterator(
child->getNumTopSegments() - 1, 0, 9999999);
gtsItRev = child->getGappedTopSegmentIterator(
child->getNumTopSegments() - 1, 9999999);
gtsItRev->toReverse();
gbsItRev = parent->getGappedBottomSegmentIterator(
child->getNumTopSegments() - 1, 0, 9999999);
gbsItRev->toReverse();
for (hal_index_t i = child->getNumTopSegments() - 1; i >= 0; --i)
{
TopSegmentIteratorConstPtr tsIt = gtsIt->getLeft();
CuAssertTrue(_testCase, tsIt->equals(gtsIt->getRight()));
CuAssertTrue(_testCase, tsIt->getTopSegment()->getArrayIndex() == i);
CuAssertTrue(_testCase, gtsIt->getReversed() == false);
gtsIt->toLeft();
BottomSegmentIteratorConstPtr bsIt = gbsIt->getLeft();
CuAssertTrue(_testCase, bsIt->equals(gbsIt->getRight()));
CuAssertTrue(_testCase, bsIt->getBottomSegment()->getArrayIndex() == i);
CuAssertTrue(_testCase, gbsIt->getReversed() == false);
gbsIt->toLeft();
TopSegmentIteratorConstPtr tsItRev = gtsItRev->getLeft();
CuAssertTrue(_testCase, tsItRev->equals(gtsItRev->getRight()));
CuAssertTrue(_testCase, tsItRev->getTopSegment()->getArrayIndex() == i);
CuAssertTrue(_testCase, gtsItRev->getReversed() == true);
gtsItRev->toRight();
BottomSegmentIteratorConstPtr bsItRev = gbsItRev->getLeft();
CuAssertTrue(_testCase, bsItRev->equals(gbsItRev->getRight()));
CuAssertTrue(_testCase, bsItRev->getBottomSegment()->getArrayIndex() == i);
CuAssertTrue(_testCase, gbsItRev->getReversed() == true);
gbsItRev->toRight();
}
}
