1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
/*
* Copyright (C) 2005, 2006, 2009 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.
*
*/
#ifndef QualifiedName_h
#define QualifiedName_h
#include <wtf/Forward.h>
#include <wtf/HashTraits.h>
#include <wtf/RefCounted.h>
#include <wtf/text/AtomicString.h>
namespace WebCore {
struct QualifiedNameComponents {
StringImpl* m_prefix;
StringImpl* m_localName;
StringImpl* m_namespace;
};
class QualifiedName {
WTF_MAKE_FAST_ALLOCATED;
public:
class QualifiedNameImpl : public RefCounted<QualifiedNameImpl> {
public:
static PassRefPtr<QualifiedNameImpl> create(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI)
{
return adoptRef(new QualifiedNameImpl(prefix, localName, namespaceURI));
}
~QualifiedNameImpl();
unsigned computeHash() const;
mutable unsigned m_existingHash;
const AtomicString m_prefix;
const AtomicString m_localName;
const AtomicString m_namespace;
mutable AtomicString m_localNameUpper;
private:
QualifiedNameImpl(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI)
: m_existingHash(0)
, m_prefix(prefix)
, m_localName(localName)
, m_namespace(namespaceURI)
{
ASSERT(!namespaceURI.isEmpty() || namespaceURI.isNull());
}
};
QualifiedName(const AtomicString& prefix, const AtomicString& localName, const AtomicString& namespaceURI);
QualifiedName(WTF::HashTableDeletedValueType) : m_impl(hashTableDeletedValue()) { }
bool isHashTableDeletedValue() const { return m_impl == hashTableDeletedValue(); }
~QualifiedName();
#ifdef QNAME_DEFAULT_CONSTRUCTOR
QualifiedName() : m_impl(0) { }
#endif
QualifiedName(const QualifiedName& other) : m_impl(other.m_impl) { ref(); }
const QualifiedName& operator=(const QualifiedName& other) { other.ref(); deref(); m_impl = other.m_impl; return *this; }
bool operator==(const QualifiedName& other) const { return m_impl == other.m_impl; }
bool operator!=(const QualifiedName& other) const { return !(*this == other); }
bool matches(const QualifiedName& other) const { return m_impl == other.m_impl || (localName() == other.localName() && namespaceURI() == other.namespaceURI()); }
bool hasPrefix() const { return m_impl->m_prefix != nullAtom; }
void setPrefix(const AtomicString& prefix) { *this = QualifiedName(prefix, localName(), namespaceURI()); }
const AtomicString& prefix() const { return m_impl->m_prefix; }
const AtomicString& localName() const { return m_impl->m_localName; }
const AtomicString& namespaceURI() const { return m_impl->m_namespace; }
// Uppercased localName, cached for efficiency
const AtomicString& localNameUpper() const;
String toString() const;
QualifiedNameImpl* impl() const { return m_impl; }
// Init routine for globals
static void init();
private:
void ref() const { m_impl->ref(); }
void deref();
static QualifiedNameImpl* hashTableDeletedValue() { return RefPtr<QualifiedNameImpl>::hashTableDeletedValue(); }
QualifiedNameImpl* m_impl;
};
#ifndef WEBCORE_QUALIFIEDNAME_HIDE_GLOBALS
extern const QualifiedName anyName;
inline const QualifiedName& anyQName() { return anyName; }
#endif
const QualifiedName& nullQName();
inline bool operator==(const AtomicString& a, const QualifiedName& q) { return a == q.localName(); }
inline bool operator!=(const AtomicString& a, const QualifiedName& q) { return a != q.localName(); }
inline bool operator==(const QualifiedName& q, const AtomicString& a) { return a == q.localName(); }
inline bool operator!=(const QualifiedName& q, const AtomicString& a) { return a != q.localName(); }
inline unsigned hashComponents(const QualifiedNameComponents& buf)
{
return StringHasher::hashMemory<sizeof(QualifiedNameComponents)>(&buf);
}
struct QualifiedNameHash {
static unsigned hash(const QualifiedName& name) { return hash(name.impl()); }
static unsigned hash(const QualifiedName::QualifiedNameImpl* name)
{
if (!name->m_existingHash)
name->m_existingHash = name->computeHash();
return name->m_existingHash;
}
static bool equal(const QualifiedName& a, const QualifiedName& b) { return a == b; }
static bool equal(const QualifiedName::QualifiedNameImpl* a, const QualifiedName::QualifiedNameImpl* b) { return a == b; }
static const bool safeToCompareToEmptyOrDeleted = false;
};
void createQualifiedName(void* targetAddress, StringImpl* name);
void createQualifiedName(void* targetAddress, StringImpl* name, const AtomicString& nameNamespace);
}
namespace WTF {
template<typename T> struct DefaultHash;
template<> struct DefaultHash<WebCore::QualifiedName> {
typedef WebCore::QualifiedNameHash Hash;
};
template<> struct HashTraits<WebCore::QualifiedName> : SimpleClassHashTraits<WebCore::QualifiedName> {
static const bool emptyValueIsZero = false;
static WebCore::QualifiedName emptyValue() { return WebCore::nullQName(); }
};
}
#endif
|
