#ifndef NamedNodeMap_h
#define NamedNodeMap_h
#include "Attribute.h"
#include "SpaceSplitString.h"
namespace WebCore {
class Node;
typedef int ExceptionCode;
class NamedNodeMap : public RefCounted<NamedNodeMap> {
friend class Element;
public:
static PassRefPtr<NamedNodeMap> create(Element* element = 0)
{
return adoptRef(new NamedNodeMap(element));
}
~NamedNodeMap();
PassRefPtr<Node> getNamedItem(const String& name) const;
PassRefPtr<Node> removeNamedItem(const String& name, ExceptionCode&);
PassRefPtr<Node> getNamedItemNS(const String& namespaceURI, const String& localName) const;
PassRefPtr<Node> removeNamedItemNS(const String& namespaceURI, const String& localName, ExceptionCode&);
PassRefPtr<Node> getNamedItem(const QualifiedName& name) const;
PassRefPtr<Node> removeNamedItem(const QualifiedName& name, ExceptionCode&);
PassRefPtr<Node> setNamedItem(Node*, ExceptionCode&);
PassRefPtr<Node> setNamedItemNS(Node*, ExceptionCode&);
PassRefPtr<Node> item(unsigned index) const;
size_t length() const { return m_attributes.size(); }
bool isEmpty() const { return !length(); }
void setAttributes(const NamedNodeMap&);
Attribute* attributeItem(unsigned index) const { return m_attributes[index].get(); }
Attribute* getAttributeItem(const QualifiedName&) const;
void copyAttributesToVector(Vector<RefPtr<Attribute> >&);
void shrinkToLength() { m_attributes.shrinkCapacity(length()); }
void reserveInitialCapacity(unsigned capacity) { m_attributes.reserveInitialCapacity(capacity); }
void insertAttribute(PassRefPtr<Attribute> newAttribute, bool allowDuplicates)
{
ASSERT(!m_element);
if (allowDuplicates || !getAttributeItem(newAttribute->name()))
addAttribute(newAttribute);
}
const AtomicString& idForStyleResolution() const { return m_idForStyleResolution; }
void setIdForStyleResolution(const AtomicString& newId) { m_idForStyleResolution = newId; }
bool mapsEquivalent(const NamedNodeMap* otherMap) const;
bool mappedMapsEquivalent(const NamedNodeMap* otherMap) const;
void addAttribute(PassRefPtr<Attribute>);
void removeAttribute(const QualifiedName&);
Element* element() const { return m_element; }
void clearClass() { m_classNames.clear(); }
void setClass(const String&);
const SpaceSplitString& classNames() const { return m_classNames; }
bool hasMappedAttributes() const { return m_mappedAttributeCount > 0; }
void declRemoved() { m_mappedAttributeCount--; }
void declAdded() { m_mappedAttributeCount++; }
private:
NamedNodeMap(Element* element)
: m_mappedAttributeCount(0)
, m_element(element)
{
}
void detachAttributesFromElement();
void detachFromElement();
Attribute* getAttributeItem(const String& name, bool shouldIgnoreAttributeCase) const;
Attribute* getAttributeItemSlowCase(const String& name, bool shouldIgnoreAttributeCase) const;
void clearAttributes();
int declCount() const;
int m_mappedAttributeCount;
SpaceSplitString m_classNames;
Element* m_element;
Vector<RefPtr<Attribute> > m_attributes;
AtomicString m_idForStyleResolution;
};
inline Attribute* NamedNodeMap::getAttributeItem(const QualifiedName& name) const
{
unsigned len = length();
for (unsigned i = 0; i < len; ++i) {
if (m_attributes[i]->name().matches(name))
return m_attributes[i].get();
}
return 0;
}
inline Attribute* NamedNodeMap::getAttributeItem(const String& name, bool shouldIgnoreAttributeCase) const
{
unsigned len = length();
bool doSlowCheck = shouldIgnoreAttributeCase;
for (unsigned i = 0; i < len; ++i) {
const QualifiedName& attrName = m_attributes[i]->name();
if (!attrName.hasPrefix()) {
if (name == attrName.localName())
return m_attributes[i].get();
} else
doSlowCheck = true;
}
if (doSlowCheck)
return getAttributeItemSlowCase(name, shouldIgnoreAttributeCase);
return 0;
}
}
#endif // NamedNodeMap_h