843f3697cc7c097d3546bc5d684427a97319e5be
[WebKit-https.git] / Source / WebCore / inspector / InspectorValues.h
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef InspectorValues_h
32 #define InspectorValues_h
33
34 #if ENABLE(INSPECTOR)
35
36 #include "PlatformString.h"
37
38 #include <wtf/Forward.h>
39 #include <wtf/HashMap.h>
40 #include <wtf/RefCounted.h>
41 #include <wtf/Vector.h>
42 #include <wtf/text/StringHash.h>
43
44 namespace WebCore {
45
46 class InspectorArray;
47 class InspectorObject;
48
49 class InspectorValue : public RefCounted<InspectorValue> {
50 public:
51     InspectorValue() : m_type(TypeNull) { }
52     virtual ~InspectorValue() { }
53
54     static PassRefPtr<InspectorValue> null()
55     {
56         return adoptRef(new InspectorValue());
57     }
58
59     typedef enum {
60         TypeNull = 0,
61         TypeBoolean,
62         TypeNumber,
63         TypeString,
64         TypeObject,
65         TypeArray
66     } Type;
67
68     Type type() const { return m_type; }
69
70     bool isNull() const { return m_type == TypeNull; }
71
72     virtual bool asBoolean(bool* output) const;
73     virtual bool asNumber(double* output) const;
74     virtual bool asNumber(long* output) const;
75     virtual bool asNumber(unsigned long* output) const;
76     virtual bool asNumber(unsigned int* output) const;
77     virtual bool asString(String* output) const;
78     virtual bool asValue(RefPtr<InspectorValue>* output);
79     virtual bool asObject(RefPtr<InspectorObject>* output);
80     virtual bool asArray(RefPtr<InspectorArray>* output);
81     virtual PassRefPtr<InspectorObject> asObject();
82     virtual PassRefPtr<InspectorArray> asArray();
83
84     static PassRefPtr<InspectorValue> parseJSON(const String& json);
85
86     String toJSONString() const;
87     virtual void writeJSON(Vector<UChar>* output) const;
88
89 protected:
90     explicit InspectorValue(Type type) : m_type(type) { }
91
92 private:
93     Type m_type;
94 };
95
96 class InspectorBasicValue : public InspectorValue {
97 public:
98
99     static PassRefPtr<InspectorBasicValue> create(bool value)
100     {
101         return adoptRef(new InspectorBasicValue(value));
102     }
103
104     static PassRefPtr<InspectorBasicValue> create(int value)
105     {
106         return adoptRef(new InspectorBasicValue(value));
107     }
108
109     static PassRefPtr<InspectorBasicValue> create(double value)
110     {
111         return adoptRef(new InspectorBasicValue(value));
112     }
113
114     virtual bool asBoolean(bool* output) const;
115     virtual bool asNumber(double* output) const;
116     virtual bool asNumber(long* output) const;
117     virtual bool asNumber(unsigned long* output) const;
118     virtual bool asNumber(unsigned int* output) const;
119
120     virtual void writeJSON(Vector<UChar>* output) const;
121
122 private:
123     explicit InspectorBasicValue(bool value) : InspectorValue(TypeBoolean), m_boolValue(value) { }
124     explicit InspectorBasicValue(int value) : InspectorValue(TypeNumber), m_doubleValue((double)value) { }
125     explicit InspectorBasicValue(double value) : InspectorValue(TypeNumber), m_doubleValue(value) { }
126
127     union {
128         bool m_boolValue;
129         double m_doubleValue;
130     };
131 };
132
133 class InspectorString : public InspectorValue {
134 public:
135     static PassRefPtr<InspectorString> create(const String& value)
136     {
137         return adoptRef(new InspectorString(value));
138     }
139
140     static PassRefPtr<InspectorString> create(const char* value)
141     {
142         return adoptRef(new InspectorString(value));
143     }
144
145     virtual bool asString(String* output) const;    
146
147     virtual void writeJSON(Vector<UChar>* output) const;
148
149 private:
150     explicit InspectorString(const String& value) : InspectorValue(TypeString), m_stringValue(value) { }
151     explicit InspectorString(const char* value) : InspectorValue(TypeString), m_stringValue(value) { }
152
153     String m_stringValue;
154 };
155
156 class InspectorObject : public InspectorValue {
157 private:
158     typedef HashMap<String, RefPtr<InspectorValue> > Dictionary;
159
160 public:
161     typedef Dictionary::iterator iterator;
162     typedef Dictionary::const_iterator const_iterator;
163
164 public:
165     static PassRefPtr<InspectorObject> create()
166     {
167         return adoptRef(new InspectorObject());
168     }
169     ~InspectorObject();
170
171     virtual bool asObject(RefPtr<InspectorObject>* output);
172     virtual PassRefPtr<InspectorObject> asObject();
173
174     void setBoolean(const String& name, bool);
175     void setNumber(const String& name, double);
176     void setString(const String& name, const String&);
177     void setValue(const String& name, PassRefPtr<InspectorValue>);
178     void setObject(const String& name, PassRefPtr<InspectorObject>);
179     void setArray(const String& name, PassRefPtr<InspectorArray>);
180
181     const_iterator find(const String& name) const;
182     bool getBoolean(const String& name, bool* output) const;
183     bool getNumber(const String& name, long* output) const;
184     bool getNumber(const String& name, double* output) const;
185     bool getString(const String& name, String* output) const;
186     PassRefPtr<InspectorObject> getObject(const String& name) const;
187     PassRefPtr<InspectorArray> getArray(const String& name) const;
188     PassRefPtr<InspectorValue> get(const String& name) const;
189
190     virtual void writeJSON(Vector<UChar>* output) const;
191
192     iterator begin() { return m_data.begin(); }
193     iterator end() { return m_data.end(); }
194     const_iterator begin() const { return m_data.begin(); }
195     const_iterator end() const { return m_data.end(); }
196
197 private:
198     InspectorObject();
199     Dictionary m_data;
200     Vector<String> m_order;
201 };
202
203 class InspectorArray : public InspectorValue {
204 public:
205     static PassRefPtr<InspectorArray> create()
206     {
207         return adoptRef(new InspectorArray());
208     }
209     ~InspectorArray();
210
211     virtual bool asArray(RefPtr<InspectorArray>* output);
212     virtual PassRefPtr<InspectorArray> asArray();
213
214     void pushBoolean(bool);
215     void pushNumber(double);
216     void pushString(const String&);
217     void pushValue(PassRefPtr<InspectorValue>);
218     void pushObject(PassRefPtr<InspectorObject>);
219     void pushArray(PassRefPtr<InspectorArray>);
220     unsigned length() const { return m_data.size(); }
221
222     PassRefPtr<InspectorValue> get(size_t index);
223
224     virtual void writeJSON(Vector<UChar>* output) const;
225
226 private:
227     InspectorArray();
228     Vector<RefPtr<InspectorValue> > m_data;
229 };
230
231 inline InspectorObject::const_iterator InspectorObject::find(const String& name) const
232 {
233     return m_data.find(name);
234 }
235
236 inline void InspectorObject::setBoolean(const String& name, bool value)
237 {
238     setValue(name, InspectorBasicValue::create(value));
239 }
240
241 inline void InspectorObject::setNumber(const String& name, double value)
242 {
243     setValue(name, InspectorBasicValue::create(value));
244 }
245
246 inline void InspectorObject::setString(const String& name, const String& value)
247 {
248     setValue(name, InspectorString::create(value));
249 }
250
251 inline void InspectorObject::setValue(const String& name, PassRefPtr<InspectorValue> value)
252 {
253     if (m_data.set(name, value).second)
254         m_order.append(name);
255 }
256
257 inline void InspectorObject::setObject(const String& name, PassRefPtr<InspectorObject> value)
258 {
259     if (m_data.set(name, value).second)
260         m_order.append(name);
261 }
262
263 inline void InspectorObject::setArray(const String& name, PassRefPtr<InspectorArray> value)
264 {
265     if (m_data.set(name, value).second)
266         m_order.append(name);
267 }
268
269 inline void InspectorArray::pushBoolean(bool value)
270 {
271     m_data.append(InspectorBasicValue::create(value));
272 }
273
274 inline void InspectorArray::pushNumber(double value)
275 {
276     m_data.append(InspectorBasicValue::create(value));
277 }
278
279 inline void InspectorArray::pushString(const String& value)
280 {
281     m_data.append(InspectorString::create(value));
282 }
283
284 inline void InspectorArray::pushValue(PassRefPtr<InspectorValue> value)
285 {
286     m_data.append(value);
287 }
288
289 inline void InspectorArray::pushObject(PassRefPtr<InspectorObject> value)
290 {
291     m_data.append(value);
292 }
293
294 inline void InspectorArray::pushArray(PassRefPtr<InspectorArray> value)
295 {
296     m_data.append(value);
297 }
298
299 } // namespace WebCore
300
301 #endif // ENABLE(INSPECTOR)
302 #endif // !defined(InspectorValues_h)