1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef MIDIPortMap_h
6 #define MIDIPortMap_h
7
8 #include "bindings/core/v8/ExceptionState.h"
9 #include "bindings/core/v8/ScriptState.h"
10 #include "bindings/core/v8/ScriptValue.h"
11 #include "bindings/core/v8/V8Binding.h"
12 #include "core/dom/Iterator.h"
13 #include "platform/heap/Handle.h"
14 #include "wtf/HashMap.h"
15 #include "wtf/text/StringHash.h"
16 #include "wtf/text/WTFString.h"
17
18 namespace blink {
19
20 template <typename T>
21 class MIDIPortMap : public GarbageCollected<MIDIPortMap<T> > {
22 public:
MIDIPortMap(const HeapHashMap<String,Member<T>> & entries)23 explicit MIDIPortMap(const HeapHashMap<String, Member<T> >& entries) : m_entries(entries) { }
24
25 // IDL attributes / methods
size()26 size_t size() const { return m_entries.size(); }
27 Iterator* keys();
28 Iterator* entries();
29 Iterator* values();
30 T* get(const String& key) const;
has(const String & key)31 bool has(const String& key) const { return m_entries.contains(key); }
iterator(ScriptState *,ExceptionState &)32 Iterator* iterator(ScriptState*, ExceptionState&) { return entries(); }
33
trace(Visitor * visitor)34 virtual void trace(Visitor* visitor)
35 {
36 visitor->trace(m_entries);
37 }
38
39 private:
40 typedef HeapHashMap<String, Member<T> > MapType;
41 typedef typename HeapHashMap<String, Member<T> >::const_iterator IteratorType;
42 struct KeySelector {
selectKeySelector43 static const String& select(ScriptState*, IteratorType i) { return i->key; }
44 };
45 struct ValueSelector {
selectValueSelector46 static T* select(ScriptState*, IteratorType i) { return i->value; }
47 };
48 struct EntrySelector {
selectEntrySelector49 static Vector<ScriptValue> select(ScriptState* scriptState, IteratorType i)
50 {
51 Vector<ScriptValue> entry;
52 entry.append(ScriptValue(scriptState, v8String(scriptState->isolate(), i->key)));
53 entry.append(ScriptValue(scriptState, V8ValueTraits<T*>::toV8Value(i->value, scriptState->context()->Global(), scriptState->isolate())));
54 return entry;
55 }
56 };
57
58 // Note: This template class relies on the fact that m_map.m_entries will
59 // never be modified once it is created.
60 template <typename Selector>
61 class MapIterator : public Iterator {
62 public:
MapIterator(MIDIPortMap<T> * map,IteratorType iterator,IteratorType end)63 MapIterator(MIDIPortMap<T>* map, IteratorType iterator, IteratorType end)
64 : m_map(map)
65 , m_iterator(iterator)
66 , m_end(end)
67 {
68 }
69
next(ScriptState * scriptState,ExceptionState &)70 virtual ScriptValue next(ScriptState* scriptState, ExceptionState&) OVERRIDE
71 {
72 if (m_iterator == m_end)
73 return ScriptValue(scriptState, v8DoneIteratorResult(scriptState->isolate()));
74 ScriptValue result(scriptState, v8IteratorResult(scriptState, Selector::select(scriptState, m_iterator)));
75 ++m_iterator;
76 return result;
77 }
78
next(ScriptState * scriptState,ScriptValue,ExceptionState & exceptionState)79 virtual ScriptValue next(ScriptState* scriptState, ScriptValue, ExceptionState& exceptionState) OVERRIDE
80 {
81 return next(scriptState, exceptionState);
82 }
83
trace(Visitor * visitor)84 virtual void trace(Visitor* visitor) OVERRIDE
85 {
86 visitor->trace(m_map);
87 Iterator::trace(visitor);
88 }
89
90 private:
91 // m_map is stored just for keeping it alive. It needs to be kept
92 // alive while JavaScript holds the iterator to it.
93 const Member<const MIDIPortMap<T> > m_map;
94 IteratorType m_iterator;
95 const IteratorType m_end;
96 };
97
98 const MapType m_entries;
99 };
100
101 template <typename T>
keys()102 Iterator* MIDIPortMap<T>::keys()
103 {
104 return new MapIterator<KeySelector>(this, m_entries.begin(), m_entries.end());
105 }
106
107 template <typename T>
entries()108 Iterator* MIDIPortMap<T>::entries()
109 {
110 return new MapIterator<EntrySelector>(this, m_entries.begin(), m_entries.end());
111 }
112
113 template <typename T>
values()114 Iterator* MIDIPortMap<T>::values()
115 {
116 return new MapIterator<ValueSelector>(this, m_entries.begin(), m_entries.end());
117 }
118
119 template <typename T>
get(const String & key)120 T* MIDIPortMap<T>::get(const String& key) const
121 {
122 return has(key) ? m_entries.get(key) : 0;
123 }
124
125 } // namespace blink
126
127 #endif
128