Remove "virtual" from all lines that have both "virtual" and "override".
[WebKit-https.git] / Source / JavaScriptCore / inspector / InspectorValues.h
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  * Copyright (C) 2014 University of Washington. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #ifndef InspectorValues_h
33 #define InspectorValues_h
34
35 #include "JSExportMacros.h"
36 #include <wtf/Assertions.h>
37 #include <wtf/HashMap.h>
38 #include <wtf/RefCounted.h>
39 #include <wtf/Vector.h>
40 #include <wtf/text/StringHash.h>
41 #include <wtf/text/WTFString.h>
42
43 namespace Inspector {
44
45 class InspectorArray;
46 class InspectorArrayBase;
47 class InspectorObject;
48 class InspectorObjectBase;
49
50 class JS_EXPORT_PRIVATE InspectorValue : public RefCounted<InspectorValue> {
51 public:
52     static const int maxDepth = 1000;
53
54     InspectorValue()
55         : m_type(Type::Null) { }
56     virtual ~InspectorValue() { }
57
58     static Ref<InspectorValue> null();
59
60     enum class Type {
61         Null = 0,
62         Boolean,
63         Double,
64         Integer,
65         String,
66         Object,
67         Array
68     };
69
70     Type type() const { return m_type; }
71
72     bool isNull() const { return m_type == Type::Null; }
73
74     virtual bool asBoolean(bool&) const;
75     virtual bool asInteger(int&) const;
76     virtual bool asInteger(unsigned&) const;
77     virtual bool asInteger(long&) const;
78     virtual bool asInteger(long long&) const;
79     virtual bool asInteger(unsigned long&) const;
80     virtual bool asInteger(unsigned long long&) const;
81     virtual bool asDouble(double&) const;
82     virtual bool asDouble(float&) const;
83     virtual bool asString(String&) const;
84     virtual bool asValue(RefPtr<InspectorValue>&);
85     virtual bool asObject(RefPtr<InspectorObject>&);
86     virtual bool asArray(RefPtr<InspectorArray>&);
87
88     static bool parseJSON(const String& jsonInput, RefPtr<InspectorValue>& output);
89
90     String toJSONString() const;
91     virtual void writeJSON(StringBuilder& output) const;
92
93 protected:
94     explicit InspectorValue(Type type) : m_type(type) { }
95
96 private:
97     Type m_type;
98 };
99
100 class JS_EXPORT_PRIVATE InspectorBasicValue : public InspectorValue {
101 public:
102
103     static Ref<InspectorBasicValue> create(bool);
104     static Ref<InspectorBasicValue> create(int);
105     static Ref<InspectorBasicValue> create(double);
106
107     bool asBoolean(bool&) const override;
108     // Numbers from the frontend are always parsed as doubles, so we allow
109     // clients to convert to integral values with this function.
110     bool asInteger(int&) const override;
111     bool asInteger(unsigned&) const override;
112     bool asInteger(long&) const override;
113     bool asInteger(long long&) const override;
114     bool asInteger(unsigned long&) const override;
115     bool asInteger(unsigned long long&) const override;
116     bool asDouble(double&) const override;
117     bool asDouble(float&) const override;
118
119     void writeJSON(StringBuilder& output) const override;
120
121 private:
122     explicit InspectorBasicValue(bool value)
123         : InspectorValue(Type::Boolean)
124         , m_booleanValue(value) { }
125
126     explicit InspectorBasicValue(int value)
127         : InspectorValue(Type::Integer)
128         , m_doubleValue(static_cast<double>(value)) { }
129
130     explicit InspectorBasicValue(double value)
131         : InspectorValue(Type::Double)
132         , m_doubleValue(value) { }
133
134     union {
135         bool m_booleanValue;
136         double m_doubleValue;
137     };
138 };
139
140 class JS_EXPORT_PRIVATE InspectorString : public InspectorValue {
141 public:
142     static Ref<InspectorString> create(const String&);
143     static Ref<InspectorString> create(const char*);
144
145     bool asString(String& output) const override;
146
147     void writeJSON(StringBuilder& output) const override;
148
149 private:
150     explicit InspectorString(const String& value)
151         : InspectorValue(Type::String)
152         , m_stringValue(value) { }
153
154     explicit InspectorString(const char* value)
155         : InspectorValue(Type::String)
156         , m_stringValue(value) { }
157
158     String m_stringValue;
159 };
160
161 class JS_EXPORT_PRIVATE InspectorObjectBase : public InspectorValue {
162 private:
163     typedef HashMap<String, RefPtr<InspectorValue>> Dictionary;
164
165 public:
166     typedef Dictionary::iterator iterator;
167     typedef Dictionary::const_iterator const_iterator;
168
169     InspectorObject* openAccessors();
170
171 protected:
172     virtual ~InspectorObjectBase();
173
174     bool asObject(RefPtr<InspectorObject>& output) override;
175
176     // FIXME: use templates to reduce the amount of duplicated set*() methods.
177     void setBoolean(const String& name, bool);
178     void setInteger(const String& name, int);
179     void setDouble(const String& name, double);
180     void setString(const String& name, const String&);
181     void setValue(const String& name, RefPtr<InspectorValue>&&);
182     void setObject(const String& name, RefPtr<InspectorObjectBase>&&);
183     void setArray(const String& name, RefPtr<InspectorArrayBase>&&);
184
185     iterator find(const String& name);
186     const_iterator find(const String& name) const;
187
188     // FIXME: use templates to reduce the amount of duplicated get*() methods.
189     bool getBoolean(const String& name, bool& output) const;
190     template<class T> bool getDouble(const String& name, T& output) const
191     {
192         RefPtr<InspectorValue> value;
193         if (!getValue(name, value))
194             return false;
195
196         return value->asDouble(output);
197     }
198     template<class T> bool getInteger(const String& name, T& output) const
199     {
200         RefPtr<InspectorValue> value;
201         if (!getValue(name, value))
202             return false;
203
204         return value->asInteger(output);
205     }
206
207     bool getString(const String& name, String& output) const;
208     bool getObject(const String& name, RefPtr<InspectorObject>&) const;
209     bool getArray(const String& name, RefPtr<InspectorArray>&) const;
210     bool getValue(const String& name, RefPtr<InspectorValue>&) const;
211
212     void remove(const String& name);
213
214     void writeJSON(StringBuilder& output) const override;
215
216     iterator begin() { return m_data.begin(); }
217     iterator end() { return m_data.end(); }
218     const_iterator begin() const { return m_data.begin(); }
219     const_iterator end() const { return m_data.end(); }
220
221     int size() const { return m_data.size(); }
222
223 protected:
224     InspectorObjectBase();
225
226 private:
227     Dictionary m_data;
228     Vector<String> m_order;
229 };
230
231 class InspectorObject : public InspectorObjectBase {
232 public:
233     static JS_EXPORT_PRIVATE Ref<InspectorObject> create();
234
235     using InspectorObjectBase::asObject;
236
237     using InspectorObjectBase::setBoolean;
238     using InspectorObjectBase::setInteger;
239     using InspectorObjectBase::setDouble;
240     using InspectorObjectBase::setString;
241     using InspectorObjectBase::setValue;
242     using InspectorObjectBase::setObject;
243     using InspectorObjectBase::setArray;
244
245     using InspectorObjectBase::find;
246     using InspectorObjectBase::getBoolean;
247     using InspectorObjectBase::getInteger;
248     using InspectorObjectBase::getDouble;
249     using InspectorObjectBase::getString;
250     using InspectorObjectBase::getObject;
251     using InspectorObjectBase::getArray;
252     using InspectorObjectBase::getValue;
253
254     using InspectorObjectBase::remove;
255
256     using InspectorObjectBase::begin;
257     using InspectorObjectBase::end;
258
259     using InspectorObjectBase::size;
260 };
261
262
263 class JS_EXPORT_PRIVATE InspectorArrayBase : public InspectorValue {
264 public:
265     typedef Vector<RefPtr<InspectorValue>>::iterator iterator;
266     typedef Vector<RefPtr<InspectorValue>>::const_iterator const_iterator;
267
268     unsigned length() const { return static_cast<unsigned>(m_data.size()); }
269
270 protected:
271     virtual ~InspectorArrayBase();
272
273     bool asArray(RefPtr<InspectorArray>&) override;
274
275     void pushBoolean(bool);
276     void pushInteger(int);
277     void pushDouble(double);
278     void pushString(const String&);
279     void pushValue(RefPtr<InspectorValue>&&);
280     void pushObject(RefPtr<InspectorObjectBase>&&);
281     void pushArray(RefPtr<InspectorArrayBase>&&);
282
283     RefPtr<InspectorValue> get(size_t index) const;
284
285     void writeJSON(StringBuilder& output) const override;
286
287     iterator begin() { return m_data.begin(); }
288     iterator end() { return m_data.end(); }
289     const_iterator begin() const { return m_data.begin(); }
290     const_iterator end() const { return m_data.end(); }
291
292 protected:
293     InspectorArrayBase();
294
295 private:
296     Vector<RefPtr<InspectorValue>> m_data;
297 };
298
299 class InspectorArray : public InspectorArrayBase {
300 public:
301     static JS_EXPORT_PRIVATE Ref<InspectorArray> create();
302
303     using InspectorArrayBase::asArray;
304
305     using InspectorArrayBase::pushBoolean;
306     using InspectorArrayBase::pushInteger;
307     using InspectorArrayBase::pushDouble;
308     using InspectorArrayBase::pushString;
309     using InspectorArrayBase::pushValue;
310     using InspectorArrayBase::pushObject;
311     using InspectorArrayBase::pushArray;
312
313     using InspectorArrayBase::get;
314
315     using InspectorArrayBase::begin;
316     using InspectorArrayBase::end;
317 };
318
319
320 inline InspectorObjectBase::iterator InspectorObjectBase::find(const String& name)
321 {
322     return m_data.find(name);
323 }
324
325 inline InspectorObjectBase::const_iterator InspectorObjectBase::find(const String& name) const
326 {
327     return m_data.find(name);
328 }
329
330 inline void InspectorObjectBase::setBoolean(const String& name, bool value)
331 {
332     setValue(name, InspectorBasicValue::create(value));
333 }
334
335 inline void InspectorObjectBase::setInteger(const String& name, int value)
336 {
337     setValue(name, InspectorBasicValue::create(value));
338 }
339
340 inline void InspectorObjectBase::setDouble(const String& name, double value)
341 {
342     setValue(name, InspectorBasicValue::create(value));
343 }
344
345 inline void InspectorObjectBase::setString(const String& name, const String& value)
346 {
347     setValue(name, InspectorString::create(value));
348 }
349
350 inline void InspectorObjectBase::setValue(const String& name, RefPtr<InspectorValue>&& value)
351 {
352     ASSERT(value);
353     if (m_data.set(name, WTFMove(value)).isNewEntry)
354         m_order.append(name);
355 }
356
357 inline void InspectorObjectBase::setObject(const String& name, RefPtr<InspectorObjectBase>&& value)
358 {
359     ASSERT(value);
360     if (m_data.set(name, WTFMove(value)).isNewEntry)
361         m_order.append(name);
362 }
363
364 inline void InspectorObjectBase::setArray(const String& name, RefPtr<InspectorArrayBase>&& value)
365 {
366     ASSERT(value);
367     if (m_data.set(name, WTFMove(value)).isNewEntry)
368         m_order.append(name);
369 }
370
371 inline void InspectorArrayBase::pushBoolean(bool value)
372 {
373     m_data.append(InspectorBasicValue::create(value));
374 }
375
376 inline void InspectorArrayBase::pushInteger(int value)
377 {
378     m_data.append(InspectorBasicValue::create(value));
379 }
380
381 inline void InspectorArrayBase::pushDouble(double value)
382 {
383     m_data.append(InspectorBasicValue::create(value));
384 }
385
386 inline void InspectorArrayBase::pushString(const String& value)
387 {
388     m_data.append(InspectorString::create(value));
389 }
390
391 inline void InspectorArrayBase::pushValue(RefPtr<InspectorValue>&& value)
392 {
393     ASSERT(value);
394     m_data.append(WTFMove(value));
395 }
396
397 inline void InspectorArrayBase::pushObject(RefPtr<InspectorObjectBase>&& value)
398 {
399     ASSERT(value);
400     m_data.append(WTFMove(value));
401 }
402
403 inline void InspectorArrayBase::pushArray(RefPtr<InspectorArrayBase>&& value)
404 {
405     ASSERT(value);
406     m_data.append(WTFMove(value));
407 }
408
409 } // namespace Inspector
410
411 #endif // !defined(InspectorValues_h)