OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserv
ed. | 2 * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserv
ed. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions are | 5 * modification, are permitted provided that the following conditions are |
6 * met: | 6 * met: |
7 * | 7 * |
8 * * Redistributions of source code must retain the above copyright | 8 * * Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * * Redistributions in binary form must reproduce the above | 10 * * Redistributions in binary form must reproduce the above |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
64 PassOwnPtrWillBeRawPtr<DocumentOrderedMap> DocumentOrderedMap::create() | 64 PassOwnPtrWillBeRawPtr<DocumentOrderedMap> DocumentOrderedMap::create() |
65 { | 65 { |
66 return adoptPtrWillBeNoop(new DocumentOrderedMap()); | 66 return adoptPtrWillBeNoop(new DocumentOrderedMap()); |
67 } | 67 } |
68 | 68 |
69 void DocumentOrderedMap::add(const AtomicString& key, Element* element) | 69 void DocumentOrderedMap::add(const AtomicString& key, Element* element) |
70 { | 70 { |
71 ASSERT(key); | 71 ASSERT(key); |
72 ASSERT(element); | 72 ASSERT(element); |
73 | 73 |
74 Map::AddResult addResult = m_map.add(key.impl(), adoptPtrWillBeNoop(new MapE
ntry(element))); | 74 Map::AddResult addResult = m_map.add(key, adoptPtrWillBeNoop(new MapEntry(el
ement))); |
75 if (addResult.isNewEntry) | 75 if (addResult.isNewEntry) |
76 return; | 76 return; |
77 | 77 |
78 OwnPtrWillBeMember<MapEntry>& entry = addResult.storedValue->value; | 78 OwnPtrWillBeMember<MapEntry>& entry = addResult.storedValue->value; |
79 ASSERT(entry->count); | 79 ASSERT(entry->count); |
80 entry->element = nullptr; | 80 entry->element = nullptr; |
81 entry->count++; | 81 entry->count++; |
82 entry->orderedList.clear(); | 82 entry->orderedList.clear(); |
83 } | 83 } |
84 | 84 |
85 void DocumentOrderedMap::remove(const AtomicString& key, Element* element) | 85 void DocumentOrderedMap::remove(const AtomicString& key, Element* element) |
86 { | 86 { |
87 ASSERT(key); | 87 ASSERT(key); |
88 ASSERT(element); | 88 ASSERT(element); |
89 | 89 |
90 Map::iterator it = m_map.find(key.impl()); | 90 Map::iterator it = m_map.find(key); |
91 if (it == m_map.end()) | 91 if (it == m_map.end()) |
92 return; | 92 return; |
93 | 93 |
94 OwnPtrWillBeMember<MapEntry>& entry = it->value; | 94 OwnPtrWillBeMember<MapEntry>& entry = it->value; |
95 ASSERT(entry->count); | 95 ASSERT(entry->count); |
96 if (entry->count == 1) { | 96 if (entry->count == 1) { |
97 ASSERT(!entry->element || entry->element == element); | 97 ASSERT(!entry->element || entry->element == element); |
98 m_map.remove(it); | 98 m_map.remove(it); |
99 } else { | 99 } else { |
100 if (entry->element == element) { | 100 if (entry->element == element) { |
101 ASSERT(entry->orderedList.isEmpty() || entry->orderedList.first() ==
element); | 101 ASSERT(entry->orderedList.isEmpty() || entry->orderedList.first() ==
element); |
102 entry->element = entry->orderedList.size() > 1 ? entry->orderedList[
1] : nullptr; | 102 entry->element = entry->orderedList.size() > 1 ? entry->orderedList[
1] : nullptr; |
103 } | 103 } |
104 entry->count--; | 104 entry->count--; |
105 entry->orderedList.clear(); | 105 entry->orderedList.clear(); |
106 } | 106 } |
107 } | 107 } |
108 | 108 |
109 template<bool keyMatches(const AtomicString&, const Element&)> | 109 template<bool keyMatches(const AtomicString&, const Element&)> |
110 inline Element* DocumentOrderedMap::get(const AtomicString& key, const TreeScope
* scope) const | 110 inline Element* DocumentOrderedMap::get(const AtomicString& key, const TreeScope
* scope) const |
111 { | 111 { |
112 ASSERT(key); | 112 ASSERT(key); |
113 ASSERT(scope); | 113 ASSERT(scope); |
114 | 114 |
115 MapEntry* entry = m_map.get(key.impl()); | 115 MapEntry* entry = m_map.get(key); |
116 if (!entry) | 116 if (!entry) |
117 return 0; | 117 return 0; |
118 | 118 |
119 ASSERT(entry->count); | 119 ASSERT(entry->count); |
120 if (entry->element) | 120 if (entry->element) |
121 return entry->element; | 121 return entry->element; |
122 | 122 |
123 // We know there's at least one node that matches; iterate to find the first
one. | 123 // We know there's at least one node that matches; iterate to find the first
one. |
124 for (Element* element = ElementTraversal::firstWithin(scope->rootNode()); el
ement; element = ElementTraversal::next(*element)) { | 124 for (Element* element = ElementTraversal::firstWithin(scope->rootNode()); el
ement; element = ElementTraversal::next(*element)) { |
125 if (!keyMatches(key, *element)) | 125 if (!keyMatches(key, *element)) |
126 continue; | 126 continue; |
127 entry->element = element; | 127 entry->element = element; |
128 return element; | 128 return element; |
129 } | 129 } |
130 ASSERT_NOT_REACHED(); | 130 ASSERT_NOT_REACHED(); |
131 return 0; | 131 return 0; |
132 } | 132 } |
133 | 133 |
134 Element* DocumentOrderedMap::getElementById(const AtomicString& key, const TreeS
cope* scope) const | 134 Element* DocumentOrderedMap::getElementById(const AtomicString& key, const TreeS
cope* scope) const |
135 { | 135 { |
136 return get<keyMatchesId>(key, scope); | 136 return get<keyMatchesId>(key, scope); |
137 } | 137 } |
138 | 138 |
139 const WillBeHeapVector<RawPtrWillBeMember<Element> >& DocumentOrderedMap::getAll
ElementsById(const AtomicString& key, const TreeScope* scope) const | 139 const WillBeHeapVector<RawPtrWillBeMember<Element> >& DocumentOrderedMap::getAll
ElementsById(const AtomicString& key, const TreeScope* scope) const |
140 { | 140 { |
141 ASSERT(key); | 141 ASSERT(key); |
142 ASSERT(scope); | 142 ASSERT(scope); |
143 DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WillBeHeapVector<RawPtrWillBeMemb
er<Element> > >, emptyVector, (adoptPtrWillBeNoop(new WillBeHeapVector<RawPtrWil
lBeMember<Element> >()))); | 143 DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WillBeHeapVector<RawPtrWillBeMemb
er<Element> > >, emptyVector, (adoptPtrWillBeNoop(new WillBeHeapVector<RawPtrWil
lBeMember<Element> >()))); |
144 | 144 |
145 Map::iterator it = m_map.find(key.impl()); | 145 Map::iterator it = m_map.find(key); |
146 if (it == m_map.end()) | 146 if (it == m_map.end()) |
147 return *emptyVector; | 147 return *emptyVector; |
148 | 148 |
149 OwnPtrWillBeMember<MapEntry>& entry = it->value; | 149 OwnPtrWillBeMember<MapEntry>& entry = it->value; |
150 ASSERT(entry->count); | 150 ASSERT(entry->count); |
151 | 151 |
152 if (entry->orderedList.isEmpty()) { | 152 if (entry->orderedList.isEmpty()) { |
153 entry->orderedList.reserveCapacity(entry->count); | 153 entry->orderedList.reserveCapacity(entry->count); |
154 for (Element* element = entry->element ? entry->element.get() : ElementT
raversal::firstWithin(scope->rootNode()); entry->orderedList.size() < entry->cou
nt; element = ElementTraversal::next(*element)) { | 154 for (Element* element = entry->element ? entry->element.get() : ElementT
raversal::firstWithin(scope->rootNode()); entry->orderedList.size() < entry->cou
nt; element = ElementTraversal::next(*element)) { |
155 ASSERT(element); | 155 ASSERT(element); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
188 | 188 |
189 void DocumentOrderedMap::MapEntry::trace(Visitor* visitor) | 189 void DocumentOrderedMap::MapEntry::trace(Visitor* visitor) |
190 { | 190 { |
191 visitor->trace(element); | 191 visitor->trace(element); |
192 #if ENABLE(OILPAN) | 192 #if ENABLE(OILPAN) |
193 visitor->trace(orderedList); | 193 visitor->trace(orderedList); |
194 #endif | 194 #endif |
195 } | 195 } |
196 | 196 |
197 } // namespace blink | 197 } // namespace blink |
OLD | NEW |