void NodeSet::traversalSort() const {
HeapHashSet<Member<Node>> nodes;
bool containsAttributeNodes = false;
unsigned nodeCount = m_nodes.size();
DCHECK_GT(nodeCount, 1u);
for (unsigned i = 0; i < nodeCount; ++i) {
Node* node = m_nodes[i].get();
nodes.add(node);
if (node->isAttributeNode())
containsAttributeNodes = true;
}
HeapVector<Member<Node>> sortedNodes;
sortedNodes.reserveInitialCapacity(nodeCount);
for (Node& n : NodeTraversal::startsAt(*findRootNode(m_nodes.first()))) {
if (nodes.contains(&n))
sortedNodes.append(&n);
if (!containsAttributeNodes || !n.isElementNode())
continue;
Element* element = toElement(&n);
AttributeCollection attributes = element->attributes();
for (auto& attribute : attributes) {
Attr* attr = element->attrIfExists(attribute.name());
if (attr && nodes.contains(attr))
sortedNodes.append(attr);
}
}
DCHECK_EQ(sortedNodes.size(), nodeCount);
const_cast<HeapVector<Member<Node>>&>(m_nodes).swap(sortedNodes);
}
void NodeSet::traversalSort() const
{
WillBeHeapHashSet<RawPtrWillBeMember<Node> > nodes;
bool containsAttributeNodes = false;
unsigned nodeCount = m_nodes.size();
ASSERT(nodeCount > 1);
for (unsigned i = 0; i < nodeCount; ++i) {
Node* node = m_nodes[i].get();
nodes.add(node);
if (node->isAttributeNode())
containsAttributeNodes = true;
}
WillBeHeapVector<RefPtrWillBeMember<Node> > sortedNodes;
sortedNodes.reserveInitialCapacity(nodeCount);
for (Node* n = findRootNode(m_nodes.first().get()); n; n = NodeTraversal::next(*n)) {
if (nodes.contains(n))
sortedNodes.append(n);
if (!containsAttributeNodes || !n->isElementNode())
continue;
Element* element = toElement(n);
if (!element->hasAttributes())
continue;
AttributeCollection attributes = element->attributes();
AttributeCollection::const_iterator end = attributes.end();
for (AttributeCollection::const_iterator it = attributes.begin(); it != end; ++it) {
RefPtrWillBeRawPtr<Attr> attr = element->attrIfExists(it->name());
if (attr && nodes.contains(attr.get()))
sortedNodes.append(attr);
}
}
ASSERT(sortedNodes.size() == nodeCount);
const_cast<WillBeHeapVector<RefPtrWillBeMember<Node> >&>(m_nodes).swap(sortedNodes);
}
void NodeSet::traversalSort() const
{
HashSet<Node*> nodes;
bool containsAttributeNodes = false;
unsigned nodeCount = m_nodes.size();
ASSERT(nodeCount > 1);
for (unsigned i = 0; i < nodeCount; ++i) {
Node* node = m_nodes[i].get();
nodes.add(node);
if (node->isAttributeNode())
containsAttributeNodes = true;
}
Vector<RefPtr<Node> > sortedNodes;
sortedNodes.reserveInitialCapacity(nodeCount);
for (Node* n = findRootNode(m_nodes.first().get()); n; n = n->traverseNextNode()) {
if (nodes.contains(n))
sortedNodes.append(n);
if (!containsAttributeNodes || !n->isElementNode())
continue;
Element* element = toElement(n);
if (!element->hasAttributes())
continue;
unsigned attributeCount = element->attributeCount();
for (unsigned i = 0; i < attributeCount; ++i) {
Attr* attribute = element->attributeItem(i)->attr();
if (attribute && nodes.contains(attribute))
sortedNodes.append(attribute);
}
}
ASSERT(sortedNodes.size() == nodeCount);
const_cast<Vector<RefPtr<Node> >&>(m_nodes).swap(sortedNodes);
}
void NodeSet::traversalSort() const
{
HashSet<Node*> nodes;
bool containsAttributeNodes = false;
unsigned nodeCount = m_nodes.size();
ASSERT(nodeCount > 1);
for (unsigned i = 0; i < nodeCount; ++i) {
Node* node = m_nodes[i].get();
nodes.add(node);
if (node->isAttributeNode())
containsAttributeNodes = true;
}
Vector<RefPtr<Node>> sortedNodes;
sortedNodes.reserveInitialCapacity(nodeCount);
for (Node* n = findRootNode(m_nodes.first().get()); n; n = NodeTraversal::next(n)) {
if (nodes.contains(n))
sortedNodes.append(n);
if (!containsAttributeNodes || !n->isElementNode())
continue;
Element* element = toElement(n);
if (!element->hasAttributes())
continue;
for (const Attribute& attribute : element->attributesIterator()) {
RefPtr<Attr> attr = element->attrIfExists(attribute.name());
if (attr && nodes.contains(attr.get()))
sortedNodes.append(attr);
}
}
ASSERT(sortedNodes.size() == nodeCount);
m_nodes = std::move(sortedNodes);
m_isSorted = true;
}
void NodeSet::traversalSort() const
{
WillBeHeapHashSet<RawPtrWillBeMember<Node>> nodes;
bool containsAttributeNodes = false;
unsigned nodeCount = m_nodes.size();
ASSERT(nodeCount > 1);
for (unsigned i = 0; i < nodeCount; ++i) {
Node* node = m_nodes[i].get();
nodes.add(node);
if (node->isAttributeNode())
containsAttributeNodes = true;
}
WillBeHeapVector<RefPtrWillBeMember<Node>> sortedNodes;
sortedNodes.reserveInitialCapacity(nodeCount);
for (Node& n : NodeTraversal::startsAt(findRootNode(m_nodes.first().get()))) {
if (nodes.contains(&n))
sortedNodes.append(&n);
if (!containsAttributeNodes || !n.isElementNode())
continue;
Element* element = toElement(&n);
AttributeCollection attributes = element->attributes();
for (auto& attribute : attributes) {
RefPtrWillBeRawPtr<Attr> attr = element->attrIfExists(attribute.name());
if (attr && nodes.contains(attr.get()))
sortedNodes.append(attr);
}
}
ASSERT(sortedNodes.size() == nodeCount);
const_cast<WillBeHeapVector<RefPtrWillBeMember<Node>>&>(m_nodes).swap(sortedNodes);
}
