/*
* Copyright (C) 2009 Google Inc. All rights reserved.
+ * Copyright (C) 2014 University of Washington. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
#ifndef InspectorValues_h
#define InspectorValues_h
-#include <wtf/Forward.h>
+#include <wtf/Assertions.h>
#include <wtf/HashMap.h>
#include <wtf/RefCounted.h>
#include <wtf/Vector.h>
namespace Inspector {
class InspectorArray;
+class InspectorArrayBase;
class InspectorObject;
+class InspectorObjectBase;
class JS_EXPORT_PRIVATE InspectorValue : public RefCounted<InspectorValue> {
public:
static const int maxDepth = 1000;
- InspectorValue() : m_type(TypeNull) { }
+ InspectorValue()
+ : m_type(Type::Null) { }
virtual ~InspectorValue() { }
- static PassRefPtr<InspectorValue> null();
+ static Ref<InspectorValue> null();
- typedef enum {
- TypeNull = 0,
- TypeBoolean,
- TypeNumber,
- TypeString,
- TypeObject,
- TypeArray
- } Type;
+ enum class Type {
+ Null = 0,
+ Boolean,
+ Double,
+ Integer,
+ String,
+ Object,
+ Array
+ };
Type type() const { return m_type; }
- bool isNull() const { return m_type == TypeNull; }
-
- virtual bool asBoolean(bool* output) const;
- virtual bool asNumber(double* output) const;
- virtual bool asNumber(float* output) const;
- virtual bool asNumber(int* output) const;
- virtual bool asNumber(unsigned* output) const;
- virtual bool asNumber(long* output) const;
- virtual bool asNumber(long long* output) const;
- virtual bool asNumber(unsigned long* output) const;
- virtual bool asNumber(unsigned long long* output) const;
- virtual bool asString(String* output) const;
- virtual bool asValue(RefPtr<InspectorValue>* output);
- virtual bool asObject(RefPtr<InspectorObject>* output);
- virtual bool asArray(RefPtr<InspectorArray>* output);
- virtual PassRefPtr<InspectorObject> asObject();
- virtual PassRefPtr<InspectorArray> asArray();
-
- static PassRefPtr<InspectorValue> parseJSON(const String& json);
+ bool isNull() const { return m_type == Type::Null; }
+
+ virtual bool asBoolean(bool&) const;
+ virtual bool asInteger(int&) const;
+ virtual bool asInteger(unsigned&) const;
+ virtual bool asInteger(long&) const;
+ virtual bool asInteger(long long&) const;
+ virtual bool asInteger(unsigned long&) const;
+ virtual bool asInteger(unsigned long long&) const;
+ virtual bool asDouble(double&) const;
+ virtual bool asDouble(float&) const;
+ virtual bool asString(String&) const;
+ virtual bool asValue(RefPtr<InspectorValue>&);
+ virtual bool asObject(RefPtr<InspectorObject>&);
+ virtual bool asArray(RefPtr<InspectorArray>&);
+
+ static bool parseJSON(const String& jsonInput, RefPtr<InspectorValue>& output);
String toJSONString() const;
- virtual void writeJSON(StringBuilder* output) const;
+ virtual void writeJSON(StringBuilder& output) const;
protected:
explicit InspectorValue(Type type) : m_type(type) { }
class JS_EXPORT_PRIVATE InspectorBasicValue : public InspectorValue {
public:
- static PassRefPtr<InspectorBasicValue> create(bool);
- static PassRefPtr<InspectorBasicValue> create(int);
- static PassRefPtr<InspectorBasicValue> create(double);
+ static Ref<InspectorBasicValue> create(bool);
+ static Ref<InspectorBasicValue> create(int);
+ static Ref<InspectorBasicValue> create(double);
- virtual bool asBoolean(bool* output) const override;
- virtual bool asNumber(double* output) const override;
- virtual bool asNumber(float* output) const override;
- virtual bool asNumber(int* output) const override;
- virtual bool asNumber(unsigned* output) const override;
- virtual bool asNumber(long* output) const override;
- virtual bool asNumber(long long* output) const override;
- virtual bool asNumber(unsigned long* output) const override;
- virtual bool asNumber(unsigned long long* output) const override;
+ virtual bool asBoolean(bool&) const override;
+ // Numbers from the frontend are always parsed as doubles, so we allow
+ // clients to convert to integral values with this function.
+ virtual bool asInteger(int&) const override;
+ virtual bool asInteger(unsigned&) const override;
+ virtual bool asInteger(long&) const override;
+ virtual bool asInteger(long long&) const override;
+ virtual bool asInteger(unsigned long&) const override;
+ virtual bool asInteger(unsigned long long&) const override;
+ virtual bool asDouble(double&) const override;
+ virtual bool asDouble(float&) const override;
- virtual void writeJSON(StringBuilder* output) const override;
+ virtual void writeJSON(StringBuilder& output) const override;
private:
- explicit InspectorBasicValue(bool value) : InspectorValue(TypeBoolean), m_boolValue(value) { }
- explicit InspectorBasicValue(int value) : InspectorValue(TypeNumber), m_doubleValue((double)value) { }
- explicit InspectorBasicValue(double value) : InspectorValue(TypeNumber), m_doubleValue(value) { }
+ explicit InspectorBasicValue(bool value)
+ : InspectorValue(Type::Boolean)
+ , m_booleanValue(value) { }
+
+ explicit InspectorBasicValue(int value)
+ : InspectorValue(Type::Integer)
+ , m_doubleValue(static_cast<double>(value)) { }
+
+ explicit InspectorBasicValue(double value)
+ : InspectorValue(Type::Double)
+ , m_doubleValue(value) { }
union {
- bool m_boolValue;
+ bool m_booleanValue;
double m_doubleValue;
};
};
class JS_EXPORT_PRIVATE InspectorString : public InspectorValue {
public:
- static PassRefPtr<InspectorString> create(const String&);
- static PassRefPtr<InspectorString> create(const char*);
+ static Ref<InspectorString> create(const String&);
+ static Ref<InspectorString> create(const char*);
- virtual bool asString(String* output) const override;
+ virtual bool asString(String& output) const override;
- virtual void writeJSON(StringBuilder* output) const override;
+ virtual void writeJSON(StringBuilder& output) const override;
private:
- explicit InspectorString(const String& value) : InspectorValue(TypeString), m_stringValue(value) { }
- explicit InspectorString(const char* value) : InspectorValue(TypeString), m_stringValue(value) { }
+ explicit InspectorString(const String& value)
+ : InspectorValue(Type::String)
+ , m_stringValue(value) { }
+
+ explicit InspectorString(const char* value)
+ : InspectorValue(Type::String)
+ , m_stringValue(value) { }
String m_stringValue;
};
typedef Dictionary::iterator iterator;
typedef Dictionary::const_iterator const_iterator;
- virtual PassRefPtr<InspectorObject> asObject() override;
InspectorObject* openAccessors();
protected:
virtual ~InspectorObjectBase();
- virtual bool asObject(RefPtr<InspectorObject>* output) override;
+ virtual bool asObject(RefPtr<InspectorObject>& output) override;
+ // FIXME: use templates to reduce the amount of duplicated set*() methods.
void setBoolean(const String& name, bool);
- void setNumber(const String& name, double);
+ void setInteger(const String& name, int);
+ void setDouble(const String& name, double);
void setString(const String& name, const String&);
- void setValue(const String& name, PassRefPtr<InspectorValue>);
- void setObject(const String& name, PassRefPtr<InspectorObject>);
- void setArray(const String& name, PassRefPtr<InspectorArray>);
+ void setValue(const String& name, RefPtr<InspectorValue>&&);
+ void setObject(const String& name, RefPtr<InspectorObjectBase>&&);
+ void setArray(const String& name, RefPtr<InspectorArrayBase>&&);
iterator find(const String& name);
const_iterator find(const String& name) const;
- bool getBoolean(const String& name, bool* output) const;
- template<class T> bool getNumber(const String& name, T* output) const
+
+ // FIXME: use templates to reduce the amount of duplicated get*() methods.
+ bool getBoolean(const String& name, bool& output) const;
+ template<class T> bool getDouble(const String& name, T& output) const
+ {
+ RefPtr<InspectorValue> value;
+ if (!getValue(name, value))
+ return false;
+
+ return value->asDouble(output);
+ }
+ template<class T> bool getInteger(const String& name, T& output) const
{
- RefPtr<InspectorValue> value = get(name);
- if (!value)
+ RefPtr<InspectorValue> value;
+ if (!getValue(name, value))
return false;
- return value->asNumber(output);
+
+ return value->asInteger(output);
}
- bool getString(const String& name, String* output) const;
- PassRefPtr<InspectorObject> getObject(const String& name) const;
- PassRefPtr<InspectorArray> getArray(const String& name) const;
- PassRefPtr<InspectorValue> get(const String& name) const;
+
+ bool getString(const String& name, String& output) const;
+ bool getObject(const String& name, RefPtr<InspectorObject>&) const;
+ bool getArray(const String& name, RefPtr<InspectorArray>&) const;
+ bool getValue(const String& name, RefPtr<InspectorValue>&) const;
void remove(const String& name);
- virtual void writeJSON(StringBuilder* output) const override;
+ virtual void writeJSON(StringBuilder& output) const override;
iterator begin() { return m_data.begin(); }
iterator end() { return m_data.end(); }
class InspectorObject : public InspectorObjectBase {
public:
- static JS_EXPORT_PRIVATE PassRefPtr<InspectorObject> create();
+ static JS_EXPORT_PRIVATE Ref<InspectorObject> create();
using InspectorObjectBase::asObject;
using InspectorObjectBase::setBoolean;
- using InspectorObjectBase::setNumber;
+ using InspectorObjectBase::setInteger;
+ using InspectorObjectBase::setDouble;
using InspectorObjectBase::setString;
using InspectorObjectBase::setValue;
using InspectorObjectBase::setObject;
using InspectorObjectBase::find;
using InspectorObjectBase::getBoolean;
- using InspectorObjectBase::getNumber;
+ using InspectorObjectBase::getInteger;
+ using InspectorObjectBase::getDouble;
using InspectorObjectBase::getString;
using InspectorObjectBase::getObject;
using InspectorObjectBase::getArray;
- using InspectorObjectBase::get;
+ using InspectorObjectBase::getValue;
using InspectorObjectBase::remove;
typedef Vector<RefPtr<InspectorValue>>::iterator iterator;
typedef Vector<RefPtr<InspectorValue>>::const_iterator const_iterator;
- virtual PassRefPtr<InspectorArray> asArray() override;
-
- unsigned length() const { return m_data.size(); }
+ unsigned length() const { return static_cast<unsigned>(m_data.size()); }
protected:
virtual ~InspectorArrayBase();
- virtual bool asArray(RefPtr<InspectorArray>* output) override;
+ virtual bool asArray(RefPtr<InspectorArray>&) override;
void pushBoolean(bool);
- void pushInt(int);
- void pushNumber(double);
+ void pushInteger(int);
+ void pushDouble(double);
void pushString(const String&);
- void pushValue(PassRefPtr<InspectorValue>);
- void pushObject(PassRefPtr<InspectorObject>);
- void pushArray(PassRefPtr<InspectorArray>);
+ void pushValue(RefPtr<InspectorValue>&&);
+ void pushObject(RefPtr<InspectorObjectBase>&&);
+ void pushArray(RefPtr<InspectorArrayBase>&&);
- PassRefPtr<InspectorValue> get(size_t index);
+ RefPtr<InspectorValue> get(size_t index) const;
- virtual void writeJSON(StringBuilder* output) const override;
+ virtual void writeJSON(StringBuilder& output) const override;
iterator begin() { return m_data.begin(); }
iterator end() { return m_data.end(); }
class InspectorArray : public InspectorArrayBase {
public:
- static JS_EXPORT_PRIVATE PassRefPtr<InspectorArray> create();
+ static JS_EXPORT_PRIVATE Ref<InspectorArray> create();
using InspectorArrayBase::asArray;
using InspectorArrayBase::pushBoolean;
- using InspectorArrayBase::pushInt;
- using InspectorArrayBase::pushNumber;
+ using InspectorArrayBase::pushInteger;
+ using InspectorArrayBase::pushDouble;
using InspectorArrayBase::pushString;
using InspectorArrayBase::pushValue;
using InspectorArrayBase::pushObject;
setValue(name, InspectorBasicValue::create(value));
}
-inline void InspectorObjectBase::setNumber(const String& name, double value)
+inline void InspectorObjectBase::setInteger(const String& name, int value)
+{
+ setValue(name, InspectorBasicValue::create(value));
+}
+
+inline void InspectorObjectBase::setDouble(const String& name, double value)
{
setValue(name, InspectorBasicValue::create(value));
}
setValue(name, InspectorString::create(value));
}
-inline void InspectorObjectBase::setValue(const String& name, PassRefPtr<InspectorValue> value)
+inline void InspectorObjectBase::setValue(const String& name, RefPtr<InspectorValue>&& value)
{
ASSERT(value);
- if (m_data.set(name, value).isNewEntry)
+ if (m_data.set(name, WTF::move(value)).isNewEntry)
m_order.append(name);
}
-inline void InspectorObjectBase::setObject(const String& name, PassRefPtr<InspectorObject> value)
+inline void InspectorObjectBase::setObject(const String& name, RefPtr<InspectorObjectBase>&& value)
{
ASSERT(value);
- if (m_data.set(name, value).isNewEntry)
+ if (m_data.set(name, WTF::move(value)).isNewEntry)
m_order.append(name);
}
-inline void InspectorObjectBase::setArray(const String& name, PassRefPtr<InspectorArray> value)
+inline void InspectorObjectBase::setArray(const String& name, RefPtr<InspectorArrayBase>&& value)
{
ASSERT(value);
- if (m_data.set(name, value).isNewEntry)
+ if (m_data.set(name, WTF::move(value)).isNewEntry)
m_order.append(name);
}
m_data.append(InspectorBasicValue::create(value));
}
-inline void InspectorArrayBase::pushInt(int value)
+inline void InspectorArrayBase::pushInteger(int value)
{
m_data.append(InspectorBasicValue::create(value));
}
-inline void InspectorArrayBase::pushNumber(double value)
+inline void InspectorArrayBase::pushDouble(double value)
{
m_data.append(InspectorBasicValue::create(value));
}
m_data.append(InspectorString::create(value));
}
-inline void InspectorArrayBase::pushValue(PassRefPtr<InspectorValue> value)
+inline void InspectorArrayBase::pushValue(RefPtr<InspectorValue>&& value)
{
ASSERT(value);
- m_data.append(value);
+ m_data.append(WTF::move(value));
}
-inline void InspectorArrayBase::pushObject(PassRefPtr<InspectorObject> value)
+inline void InspectorArrayBase::pushObject(RefPtr<InspectorObjectBase>&& value)
{
ASSERT(value);
- m_data.append(value);
+ m_data.append(WTF::move(value));
}
-inline void InspectorArrayBase::pushArray(PassRefPtr<InspectorArray> value)
+inline void InspectorArrayBase::pushArray(RefPtr<InspectorArrayBase>&& value)
{
ASSERT(value);
- m_data.append(value);
+ m_data.append(WTF::move(value));
}
} // namespace Inspector
projects / apple / javascriptcore.git / blobdiff