diff options
Diffstat (limited to 'src/3rdparty/webkit/WebCore/dom/DynamicNodeList.cpp')
-rw-r--r-- | src/3rdparty/webkit/WebCore/dom/DynamicNodeList.cpp | 172 |
1 files changed, 172 insertions, 0 deletions
diff --git a/src/3rdparty/webkit/WebCore/dom/DynamicNodeList.cpp b/src/3rdparty/webkit/WebCore/dom/DynamicNodeList.cpp new file mode 100644 index 0000000..eeb9833 --- /dev/null +++ b/src/3rdparty/webkit/WebCore/dom/DynamicNodeList.cpp @@ -0,0 +1,172 @@ +/* + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2001 Dirk Mueller (mueller@kde.org) + * Copyright (C) 2004, 2006, 2007, 2008 Apple Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + */ + +#include "config.h" +#include "DynamicNodeList.h" + +#include "Document.h" +#include "Element.h" + +namespace WebCore { + +DynamicNodeList::DynamicNodeList(PassRefPtr<Node> rootNode) + : m_rootNode(rootNode) + , m_caches(new Caches) + , m_ownsCaches(true) +{ + m_rootNode->registerDynamicNodeList(this); +} + +DynamicNodeList::DynamicNodeList(PassRefPtr<Node> rootNode, DynamicNodeList::Caches* caches) + : m_rootNode(rootNode) + , m_caches(caches) + , m_ownsCaches(false) +{ + m_rootNode->registerDynamicNodeList(this); + ++caches->refCount; +} + +DynamicNodeList::~DynamicNodeList() +{ + m_rootNode->unregisterDynamicNodeList(this); + if (m_ownsCaches) + delete m_caches; + else + --m_caches->refCount; +} + +unsigned DynamicNodeList::length() const +{ + if (m_caches->isLengthCacheValid) + return m_caches->cachedLength; + + unsigned length = 0; + + for (Node* n = m_rootNode->firstChild(); n; n = n->traverseNextNode(m_rootNode.get())) + length += n->isElementNode() && nodeMatches(static_cast<Element*>(n)); + + m_caches->cachedLength = length; + m_caches->isLengthCacheValid = true; + + return length; +} + +Node* DynamicNodeList::itemForwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const +{ + ASSERT(remainingOffset >= 0); + for (Node* n = start; n; n = n->traverseNextNode(m_rootNode.get())) { + if (n->isElementNode() && nodeMatches(static_cast<Element*>(n))) { + if (!remainingOffset) { + m_caches->lastItem = n; + m_caches->lastItemOffset = offset; + m_caches->isItemCacheValid = true; + return n; + } + --remainingOffset; + } + } + + return 0; // no matching node in this subtree +} + +Node* DynamicNodeList::itemBackwardsFromCurrent(Node* start, unsigned offset, int remainingOffset) const +{ + ASSERT(remainingOffset < 0); + for (Node* n = start; n; n = n->traversePreviousNode(m_rootNode.get())) { + if (n->isElementNode() && nodeMatches(static_cast<Element*>(n))) { + if (!remainingOffset) { + m_caches->lastItem = n; + m_caches->lastItemOffset = offset; + m_caches->isItemCacheValid = true; + return n; + } + ++remainingOffset; + } + } + + return 0; // no matching node in this subtree +} + +Node* DynamicNodeList::item(unsigned offset) const +{ + int remainingOffset = offset; + Node* start = m_rootNode->firstChild(); + if (m_caches->isItemCacheValid) { + if (offset == m_caches->lastItemOffset) + return m_caches->lastItem; + else if (offset > m_caches->lastItemOffset || m_caches->lastItemOffset - offset < offset) { + start = m_caches->lastItem; + remainingOffset -= m_caches->lastItemOffset; + } + } + + if (remainingOffset < 0) + return itemBackwardsFromCurrent(start, offset, remainingOffset); + return itemForwardsFromCurrent(start, offset, remainingOffset); +} + +Node* DynamicNodeList::itemWithName(const AtomicString& elementId) const +{ + if (m_rootNode->isDocumentNode() || m_rootNode->inDocument()) { + Element* node = m_rootNode->document()->getElementById(elementId); + if (node && nodeMatches(node)) { + for (Node* p = node->parentNode(); p; p = p->parentNode()) { + if (p == m_rootNode) + return node; + } + } + return 0; + } + + unsigned length = this->length(); + for (unsigned i = 0; i < length; i++) { + Node* node = item(i); + if (node->isElementNode() && static_cast<Element*>(node)->getIDAttribute() == elementId) + return node; + } + + return 0; +} + +void DynamicNodeList::invalidateCache() +{ + // This should only be called for node lists that own their own caches. + ASSERT(m_ownsCaches); + m_caches->reset(); +} + +DynamicNodeList::Caches::Caches() + : lastItem(0) + , isLengthCacheValid(false) + , isItemCacheValid(false) + , refCount(0) +{ +} + +void DynamicNodeList::Caches::reset() +{ + lastItem = 0; + isLengthCacheValid = false; + isItemCacheValid = false; +} + +} // namespace WebCore |