Method set_intersect

kdevplatform/language/util/setrepository.cpp:695–785

}

uint SetRepositoryAlgorithms::set_intersect(uint firstNode, uint secondNode, const SetNodeData* first,
                                            const SetNodeData* second, uchar splitBit)
{
    if (firstNode == secondNode)
        return firstNode;

    if (first->start() >= second->end())
        return 0;

    if (second->start() >= first->end())
        return 0;

    //The ranges of first and second do intersect
    uint firstStart = first->start(), firstEnd = first->end(), secondStart = second->start(), secondEnd = second->end();

    uint newStart = firstStart < secondStart ? firstStart : secondStart;
    uint newEnd = firstEnd > secondEnd ? firstEnd : secondEnd;

    //Compute the split-position for the resulting merged node
    uint splitPosition = splitPositionForRange(newStart, newEnd, splitBit);

    //Since the ranges overlap, we can be sure that either first or second contain splitPosition.
    //The node that contains it, will also be split by it.

    if (splitPosition > firstStart && splitPosition < firstEnd && splitPosition > secondStart &&
        splitPosition < secondEnd) {
        //The split-position intersect with both first and second. Continue the intersection on both sides

        uint firstLeftNode = first->leftNode();
        uint firstRightNode = first->rightNode();

        uint secondLeftNode = second->leftNode();
        uint secondRightNode = second->rightNode();

        const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
        const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);
        const SetNodeData* secondLeft = repository.itemFromIndex(secondLeftNode);
        const SetNodeData* secondRight = repository.itemFromIndex(secondRightNode);

        Q_ASSERT(splitPosition >= firstLeft->end() && splitPosition <= firstRight->start());
        Q_ASSERT(splitPosition >= secondLeft->end() && splitPosition <= secondRight->start());

        uint newLeftNode = set_intersect(firstLeftNode, secondLeftNode, firstLeft, secondLeft, splitBit);
        uint newRightNode = set_intersect(firstRightNode, secondRightNode, firstRight, secondRight, splitBit);

        if (newLeftNode && newRightNode)
            return createSetFromNodes(newLeftNode, newRightNode);
        else if (newLeftNode)
            return newLeftNode;
        else
            return newRightNode;
    } else if (splitPosition > firstStart && splitPosition < firstEnd) {
        uint firstLeftNode = first->leftNode();
        uint firstRightNode = first->rightNode();

        const SetNodeData* firstLeft = repository.itemFromIndex(firstLeftNode);
        const SetNodeData* firstRight = repository.itemFromIndex(firstRightNode);