#include "config.h"
#include "TreeWalker.h"
#include "ContainerNode.h"
#include "ExceptionCode.h"
#include "NodeTraversal.h"
namespace WebCore {
TreeWalker::TreeWalker(Node& rootNode, unsigned long whatToShow, RefPtr<NodeFilter>&& filter)
: NodeIteratorBase(rootNode, whatToShow, WTFMove(filter))
, m_current(root())
{
}
void TreeWalker::setCurrentNode(Node& node)
{
m_current = node;
}
inline Node* TreeWalker::setCurrent(Ref<Node>&& node)
{
m_current = WTFMove(node);
return m_current.ptr();
}
ExceptionOr<Node*> TreeWalker::parentNode()
{
RefPtr<Node> node = m_current.ptr();
while (node != &root()) {
node = node->parentNode();
if (!node)
return nullptr;
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.releaseNonNull());
}
return nullptr;
}
ExceptionOr<Node*> TreeWalker::firstChild()
{
for (RefPtr<Node> node = m_current->firstChild(); node; ) {
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = node.releaseNonNull();
return m_current.ptr();
case NodeFilter::FILTER_SKIP:
if (node->firstChild()) {
node = node->firstChild();
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
do {
if (node->nextSibling()) {
node = node->nextSibling();
break;
}
ContainerNode* parent = node->parentNode();
if (!parent || parent == &root() || parent == m_current.ptr())
return nullptr;
node = parent;
} while (node);
}
return nullptr;
}
ExceptionOr<Node*> TreeWalker::lastChild()
{
for (RefPtr<Node> node = m_current->lastChild(); node; ) {
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
switch (acceptNodeResult) {
case NodeFilter::FILTER_ACCEPT:
m_current = node.releaseNonNull();
return m_current.ptr();
case NodeFilter::FILTER_SKIP:
if (node->lastChild()) {
node = node->lastChild();
continue;
}
break;
case NodeFilter::FILTER_REJECT:
break;
}
do {
if (node->previousSibling()) {
node = node->previousSibling();
break;
}
ContainerNode* parent = node->parentNode();
if (!parent || parent == &root() || parent == m_current.ptr())
return nullptr;
node = parent;
} while (node);
}
return nullptr;
}
template<TreeWalker::SiblingTraversalType type> ExceptionOr<Node*> TreeWalker::traverseSiblings()
{
RefPtr<Node> node = m_current.ptr();
if (node == &root())
return nullptr;
auto isNext = type == SiblingTraversalType::Next;
while (true) {
for (RefPtr<Node> sibling = isNext ? node->nextSibling() : node->previousSibling(); sibling; ) {
auto callbackResult = acceptNode(*sibling);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) {
m_current = sibling.releaseNonNull();
return m_current.ptr();
}
node = sibling;
sibling = isNext ? sibling->firstChild() : sibling->lastChild();
if (acceptNodeResult == NodeFilter::FILTER_REJECT || !sibling)
sibling = isNext ? node->nextSibling() : node->previousSibling();
}
node = node->parentNode();
if (!node || node == &root())
return nullptr;
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return nullptr;
}
}
ExceptionOr<Node*> TreeWalker::previousSibling()
{
return traverseSiblings<SiblingTraversalType::Previous>();
}
ExceptionOr<Node*> TreeWalker::nextSibling()
{
return traverseSiblings<SiblingTraversalType::Next>();
}
ExceptionOr<Node*> TreeWalker::previousNode()
{
RefPtr<Node> node = m_current.ptr();
while (node != &root()) {
while (Node* previousSibling = node->previousSibling()) {
node = previousSibling;
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
continue;
while (Node* lastChild = node->lastChild()) {
node = lastChild;
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT) {
m_current = node.releaseNonNull();
return m_current.ptr();
}
}
if (node == &root())
return nullptr;
ContainerNode* parent = node->parentNode();
if (!parent)
return nullptr;
node = parent;
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.releaseNonNull());
}
return nullptr;
}
ExceptionOr<Node*> TreeWalker::nextNode()
{
RefPtr<Node> node = m_current.ptr();
Children:
while (Node* firstChild = node->firstChild()) {
node = firstChild;
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.releaseNonNull());
if (acceptNodeResult == NodeFilter::FILTER_REJECT)
break;
}
while (Node* nextSibling = NodeTraversal::nextSkippingChildren(*node, &root())) {
node = nextSibling;
auto callbackResult = acceptNode(*node);
if (callbackResult.type() == CallbackResultType::ExceptionThrown)
return Exception { ExistingExceptionError };
ASSERT(callbackResult.type() == CallbackResultType::Success);
auto acceptNodeResult = callbackResult.releaseReturnValue();
if (acceptNodeResult == NodeFilter::FILTER_ACCEPT)
return setCurrent(node.releaseNonNull());
if (acceptNodeResult == NodeFilter::FILTER_SKIP)
goto Children;
}
return nullptr;
}
}