#include "config.h"
#include "SimpleRange.h"
#include "CharacterData.h"
#include "NodeTraversal.h"
namespace WebCore {
SimpleRange::SimpleRange(const BoundaryPoint& start, const BoundaryPoint& end)
: start(start)
, end(end)
{
}
SimpleRange::SimpleRange(BoundaryPoint&& start, BoundaryPoint&& end)
: start(WTFMove(start))
, end(WTFMove(end))
{
}
bool operator==(const SimpleRange& a, const SimpleRange& b)
{
return a.start == b.start && a.end == b.end;
}
Optional<BoundaryPoint> makeBoundaryPointBeforeNode(Node& node)
{
auto parent = node.parentNode();
if (!parent)
return WTF::nullopt;
return BoundaryPoint { *parent, node.computeNodeIndex() };
}
Optional<BoundaryPoint> makeBoundaryPointAfterNode(Node& node)
{
auto parent = node.parentNode();
if (!parent)
return WTF::nullopt;
return BoundaryPoint { *parent, node.computeNodeIndex() + 1 };
}
static bool isOffsetBeforeChild(ContainerNode& container, unsigned offset, Node& child)
{
if (!offset)
return true;
if (child.parentNode() != &container)
return false;
unsigned currentOffset = 0;
for (auto currentChild = container.firstChild(); currentChild && currentChild != &child; currentChild = currentChild->nextSibling()) {
if (offset <= ++currentOffset)
return true;
}
return false;
}
static PartialOrdering order(unsigned a, unsigned b)
{
if (a < b)
return PartialOrdering::less;
if (a > b)
return PartialOrdering::greater;
return PartialOrdering::equivalent;
}
PartialOrdering documentOrder(const BoundaryPoint& a, const BoundaryPoint& b)
{
if (a.container.ptr() == b.container.ptr())
return order(a.offset, b.offset);
for (auto ancestor = b.container.ptr(); ancestor; ) {
auto nextAncestor = ancestor->parentInComposedTree();
if (nextAncestor == a.container.ptr())
return isOffsetBeforeChild(*nextAncestor, a.offset, *ancestor) ? PartialOrdering::less : PartialOrdering::greater;
ancestor = nextAncestor;
}
for (auto ancestor = a.container.ptr(); ancestor; ) {
auto nextAncestor = ancestor->parentInComposedTree();
if (nextAncestor == b.container.ptr())
return isOffsetBeforeChild(*nextAncestor, b.offset, *ancestor) ? PartialOrdering::greater : PartialOrdering::less;
ancestor = nextAncestor;
}
return documentOrder(a.container, b.container);
}
Optional<SimpleRange> makeRangeSelectingNode(Node& node)
{
auto parent = node.parentNode();
if (!parent)
return WTF::nullopt;
unsigned offset = node.computeNodeIndex();
return SimpleRange { { *parent, offset }, { *parent, offset + 1 } };
}
SimpleRange makeRangeSelectingNodeContents(Node& node)
{
return { makeBoundaryPointBeforeNodeContents(node), makeBoundaryPointAfterNodeContents(node) };
}
OffsetRange characterDataOffsetRange(const SimpleRange& range, const Node& node)
{
return { &node == range.start.container.ptr() ? range.start.offset : 0,
&node == range.end.container.ptr() ? range.end.offset : std::numeric_limits<unsigned>::max() };
}
static RefPtr<Node> firstIntersectingNode(const SimpleRange& range)
{
if (range.start.container->isCharacterDataNode())
return range.start.container.ptr();
if (auto child = range.start.container->traverseToChildAt(range.start.offset))
return child;
return NodeTraversal::nextSkippingChildren(range.start.container);
}
static RefPtr<Node> nodePastLastIntersectingNode(const SimpleRange& range)
{
if (range.end.container->isCharacterDataNode())
return NodeTraversal::nextSkippingChildren(range.end.container);
if (auto child = range.end.container->traverseToChildAt(range.end.offset))
return child;
return NodeTraversal::nextSkippingChildren(range.end.container);
}
IntersectingNodeIterator::IntersectingNodeIterator(const SimpleRange& range)
: m_node(firstIntersectingNode(range))
, m_pastLastNode(nodePastLastIntersectingNode(range))
{
enforceEndInvariant();
}
void IntersectingNodeIterator::advance()
{
ASSERT(m_node);
m_node = NodeTraversal::next(*m_node);
enforceEndInvariant();
}
void IntersectingNodeIterator::advanceSkippingChildren()
{
ASSERT(m_node);
m_node = m_node->contains(m_pastLastNode.get()) ? nullptr : NodeTraversal::nextSkippingChildren(*m_node);
enforceEndInvariant();
}
void IntersectingNodeIterator::enforceEndInvariant()
{
if (m_node == m_pastLastNode || !m_node) {
m_node = nullptr;
m_pastLastNode = nullptr;
}
}
RefPtr<Node> commonInclusiveAncestor(const SimpleRange& range)
{
return commonInclusiveAncestor(range.start.container, range.end.container);
}
}