#pragma once
#include <wtf/HashMap.h>
#include <wtf/text/StringHash.h>
#include <wtf/text/WTFString.h>
namespace WTF {
namespace JSONImpl {
class Array;
class ArrayBase;
class Object;
class ObjectBase;
class WTF_EXPORT_PRIVATE Value : public RefCounted<Value> {
public:
static constexpr int maxDepth = 1000;
virtual ~Value()
{
switch (m_type) {
case Type::Null:
case Type::Boolean:
case Type::Double:
case Type::Integer:
break;
case Type::String:
if (m_value.string)
m_value.string->deref();
break;
case Type::Object:
case Type::Array:
break;
}
}
static Ref<Value> null();
static Ref<Value> create(bool);
static Ref<Value> create(int);
static Ref<Value> create(double);
static Ref<Value> create(const String&);
template<class T>
static Ref<Value> create(T) = delete;
enum class Type {
Null = 0,
Boolean,
Double,
Integer,
String,
Object,
Array,
};
Type type() const { return m_type; }
bool isNull() const { return m_type == Type::Null; }
Optional<bool> asBoolean() const;
Optional<int> asInteger() const;
Optional<double> asDouble() const;
String asString() const;
RefPtr<Value> asValue();
virtual RefPtr<Object> asObject();
virtual RefPtr<Array> asArray();
static RefPtr<Value> parseJSON(const String&);
static void escapeString(StringBuilder&, StringView);
String toJSONString() const;
virtual void writeJSON(StringBuilder& output) const;
virtual size_t memoryCost() const;
bool asDouble(double&) const;
bool asInteger(int&) const;
bool asString(String&) const;
protected:
Value()
: m_type { Type::Null }
{
}
explicit Value(Type type)
: m_type(type)
{
}
explicit Value(bool value)
: m_type { Type::Boolean }
{
m_value.boolean = value;
}
explicit Value(int value)
: m_type { Type::Integer }
{
m_value.number = static_cast<double>(value);
}
explicit Value(double value)
: m_type(Type::Double)
{
m_value.number = value;
}
explicit Value(const String& value)
: m_type { Type::String }
{
m_value.string = value.impl();
if (m_value.string)
m_value.string->ref();
}
private:
Type m_type { Type::Null };
union {
bool boolean;
double number;
StringImpl* string;
} m_value;
};
class WTF_EXPORT_PRIVATE ObjectBase : public Value {
private:
using DataStorage = HashMap<String, Ref<Value>>;
using OrderStorage = Vector<String>;
public:
using iterator = DataStorage::iterator;
using const_iterator = DataStorage::const_iterator;
RefPtr<Object> asObject() final;
size_t memoryCost() const final;
protected:
~ObjectBase() override;
void setBoolean(const String& name, bool);
void setInteger(const String& name, int);
void setDouble(const String& name, double);
void setString(const String& name, const String&);
void setValue(const String& name, Ref<Value>&&);
void setObject(const String& name, Ref<ObjectBase>&&);
void setArray(const String& name, Ref<ArrayBase>&&);
iterator find(const String& name);
const_iterator find(const String& name) const;
Optional<bool> getBoolean(const String& name) const;
Optional<double> getDouble(const String& name) const;
Optional<int> getInteger(const String& name) const;
String getString(const String& name) const;
RefPtr<Object> getObject(const String& name) const;
RefPtr<Array> getArray(const String& name) const;
RefPtr<Value> getValue(const String& name) const;
void remove(const String& name);
void writeJSON(StringBuilder& output) const final;
iterator begin() { return m_map.begin(); }
iterator end() { return m_map.end(); }
const_iterator begin() const { return m_map.begin(); }
const_iterator end() const { return m_map.end(); }
unsigned size() const { return m_map.size(); }
bool getBoolean(const String& name, bool& output) const;
bool getString(const String& name, String& output) const;
bool getObject(const String& name, RefPtr<Object>& output) const;
bool getArray(const String& name, RefPtr<Array>& output) const;
bool getValue(const String& name, RefPtr<Value>& output) const;
protected:
ObjectBase();
private:
DataStorage m_map;
OrderStorage m_order;
};
class Object : public ObjectBase {
public:
static WTF_EXPORT_PRIVATE Ref<Object> create();
using ObjectBase::setBoolean;
using ObjectBase::setInteger;
using ObjectBase::setDouble;
using ObjectBase::setString;
using ObjectBase::setValue;
using ObjectBase::setObject;
using ObjectBase::setArray;
using ObjectBase::find;
using ObjectBase::getBoolean;
using ObjectBase::getInteger;
using ObjectBase::getDouble;
using ObjectBase::getString;
using ObjectBase::getObject;
using ObjectBase::getArray;
using ObjectBase::getValue;
using ObjectBase::remove;
using ObjectBase::begin;
using ObjectBase::end;
using ObjectBase::size;
};
class WTF_EXPORT_PRIVATE ArrayBase : public Value {
private:
using DataStorage = Vector<Ref<Value>>;
public:
using iterator = DataStorage::iterator;
using const_iterator = DataStorage::const_iterator;
size_t length() const { return m_map.size(); }
Ref<Value> get(size_t index) const;
size_t memoryCost() const final;
RefPtr<Array> asArray() final;
protected:
~ArrayBase() override;
void pushBoolean(bool);
void pushInteger(int);
void pushDouble(double);
void pushString(const String&);
void pushValue(Ref<Value>&&);
void pushObject(Ref<ObjectBase>&&);
void pushArray(Ref<ArrayBase>&&);
iterator begin() { return m_map.begin(); }
iterator end() { return m_map.end(); }
const_iterator begin() const { return m_map.begin(); }
const_iterator end() const { return m_map.end(); }
void writeJSON(StringBuilder& output) const final;
protected:
ArrayBase();
private:
DataStorage m_map;
};
class Array final : public ArrayBase {
public:
static WTF_EXPORT_PRIVATE Ref<Array> create();
using ArrayBase::pushBoolean;
using ArrayBase::pushInteger;
using ArrayBase::pushDouble;
using ArrayBase::pushString;
using ArrayBase::pushValue;
using ArrayBase::pushObject;
using ArrayBase::pushArray;
using ArrayBase::get;
using ArrayBase::begin;
using ArrayBase::end;
};
inline ObjectBase::iterator ObjectBase::find(const String& name)
{
return m_map.find(name);
}
inline ObjectBase::const_iterator ObjectBase::find(const String& name) const
{
return m_map.find(name);
}
inline void ObjectBase::setBoolean(const String& name, bool value)
{
setValue(name, Value::create(value));
}
inline void ObjectBase::setInteger(const String& name, int value)
{
setValue(name, Value::create(value));
}
inline void ObjectBase::setDouble(const String& name, double value)
{
setValue(name, Value::create(value));
}
inline void ObjectBase::setString(const String& name, const String& value)
{
setValue(name, Value::create(value));
}
inline void ObjectBase::setValue(const String& name, Ref<Value>&& value)
{
if (m_map.set(name, WTFMove(value)).isNewEntry)
m_order.append(name);
}
inline void ObjectBase::setObject(const String& name, Ref<ObjectBase>&& value)
{
if (m_map.set(name, WTFMove(value)).isNewEntry)
m_order.append(name);
}
inline void ObjectBase::setArray(const String& name, Ref<ArrayBase>&& value)
{
if (m_map.set(name, WTFMove(value)).isNewEntry)
m_order.append(name);
}
inline void ArrayBase::pushBoolean(bool value)
{
m_map.append(Value::create(value));
}
inline void ArrayBase::pushInteger(int value)
{
m_map.append(Value::create(value));
}
inline void ArrayBase::pushDouble(double value)
{
m_map.append(Value::create(value));
}
inline void ArrayBase::pushString(const String& value)
{
m_map.append(Value::create(value));
}
inline void ArrayBase::pushValue(Ref<Value>&& value)
{
m_map.append(WTFMove(value));
}
inline void ArrayBase::pushObject(Ref<ObjectBase>&& value)
{
m_map.append(WTFMove(value));
}
inline void ArrayBase::pushArray(Ref<ArrayBase>&& value)
{
m_map.append(WTFMove(value));
}
template<typename T>
class ArrayOf final : public ArrayBase {
private:
ArrayOf() { }
Array& castedArray()
{
COMPILE_ASSERT(sizeof(Array) == sizeof(ArrayOf<T>), cannot_cast);
return *static_cast<Array*>(static_cast<ArrayBase*>(this));
}
public:
template <typename V = T>
std::enable_if_t<std::is_same_v<bool, V> || std::is_same_v<Value, V>> addItem(bool value)
{
castedArray().pushBoolean(value);
}
template <typename V = T>
std::enable_if_t<std::is_same_v<int, V> || std::is_same_v<Value, V>> addItem(int value)
{
castedArray().pushInteger(value);
}
template <typename V = T>
std::enable_if_t<std::is_same_v<double, V> || std::is_same_v<Value, V>> addItem(double value)
{
castedArray().pushDouble(value);
}
template <typename V = T>
std::enable_if_t<std::is_same_v<String, V> || std::is_same_v<Value, V>> addItem(const String& value)
{
castedArray().pushString(value);
}
template <typename V = T>
std::enable_if_t<std::is_base_of_v<Value, V> && !std::is_base_of_v<ObjectBase, V> && !std::is_base_of_v<ArrayBase, V>> addItem(Ref<Value>&& value)
{
castedArray().pushValue(WTFMove(value));
}
template <typename V = T>
std::enable_if_t<std::is_base_of_v<ObjectBase, V>> addItem(Ref<ObjectBase>&& value)
{
castedArray().pushObject(WTFMove(value));
}
template <typename V = T>
std::enable_if_t<std::is_base_of_v<ArrayBase, V>> addItem(Ref<ArrayBase>&& value)
{
castedArray().pushArray(WTFMove(value));
}
static Ref<ArrayOf<T>> create()
{
return adoptRef(*new ArrayOf<T>());
}
using ArrayBase::get;
using ArrayBase::begin;
using ArrayBase::end;
};
}
}
namespace JSON {
using namespace WTF::JSONImpl;
}