blob: d3ebab16f51d9bd9411c342736f842a56d2fd4b6 [file] [log] [blame]
//===-- StructuredData.h ----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_StructuredData_h_
#define liblldb_StructuredData_h_
#include "llvm/ADT/StringRef.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/FileSpec.h" // for FileSpec
#include "lldb/lldb-enumerations.h" // for StructuredDataType
#include <cassert> // for assert
#include <cstddef> // for size_t
#include <cstdint> // for uint64_t
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <type_traits> // for move
#include <utility>
#include <vector>
namespace lldb_private {
class Status;
}
namespace lldb_private {
class Stream;
}
namespace lldb_private {
//----------------------------------------------------------------------
/// @class StructuredData StructuredData.h "lldb/Utility/StructuredData.h"
/// A class which can hold structured data
///
/// The StructuredData class is designed to hold the data from a JSON or plist
/// style file -- a serialized data structure with dictionaries (maps,
/// hashes), arrays, and concrete values like integers, floating point
/// numbers, strings, booleans.
///
/// StructuredData does not presuppose any knowledge of the schema for the
/// data it is holding; it can parse JSON data, for instance, and other parts
/// of lldb can iterate through the parsed data set to find keys and values
/// that may be present.
//----------------------------------------------------------------------
class StructuredData {
public:
class Object;
class Array;
class Integer;
class Float;
class Boolean;
class String;
class Dictionary;
class Generic;
typedef std::shared_ptr<Object> ObjectSP;
typedef std::shared_ptr<Array> ArraySP;
typedef std::shared_ptr<Integer> IntegerSP;
typedef std::shared_ptr<Float> FloatSP;
typedef std::shared_ptr<Boolean> BooleanSP;
typedef std::shared_ptr<String> StringSP;
typedef std::shared_ptr<Dictionary> DictionarySP;
typedef std::shared_ptr<Generic> GenericSP;
class Object : public std::enable_shared_from_this<Object> {
public:
Object(lldb::StructuredDataType t = lldb::eStructuredDataTypeInvalid)
: m_type(t) {}
virtual ~Object() = default;
virtual bool IsValid() const { return true; }
virtual void Clear() { m_type = lldb::eStructuredDataTypeInvalid; }
lldb::StructuredDataType GetType() const { return m_type; }
void SetType(lldb::StructuredDataType t) { m_type = t; }
Array *GetAsArray() {
return ((m_type == lldb::eStructuredDataTypeArray)
? static_cast<Array *>(this)
: nullptr);
}
Dictionary *GetAsDictionary() {
return ((m_type == lldb::eStructuredDataTypeDictionary)
? static_cast<Dictionary *>(this)
: nullptr);
}
Integer *GetAsInteger() {
return ((m_type == lldb::eStructuredDataTypeInteger)
? static_cast<Integer *>(this)
: nullptr);
}
uint64_t GetIntegerValue(uint64_t fail_value = 0) {
Integer *integer = GetAsInteger();
return ((integer != nullptr) ? integer->GetValue() : fail_value);
}
Float *GetAsFloat() {
return ((m_type == lldb::eStructuredDataTypeFloat)
? static_cast<Float *>(this)
: nullptr);
}
double GetFloatValue(double fail_value = 0.0) {
Float *f = GetAsFloat();
return ((f != nullptr) ? f->GetValue() : fail_value);
}
Boolean *GetAsBoolean() {
return ((m_type == lldb::eStructuredDataTypeBoolean)
? static_cast<Boolean *>(this)
: nullptr);
}
bool GetBooleanValue(bool fail_value = false) {
Boolean *b = GetAsBoolean();
return ((b != nullptr) ? b->GetValue() : fail_value);
}
String *GetAsString() {
return ((m_type == lldb::eStructuredDataTypeString)
? static_cast<String *>(this)
: nullptr);
}
llvm::StringRef GetStringValue(const char *fail_value = nullptr) {
String *s = GetAsString();
if (s)
return s->GetValue();
return fail_value;
}
Generic *GetAsGeneric() {
return ((m_type == lldb::eStructuredDataTypeGeneric)
? static_cast<Generic *>(this)
: nullptr);
}
ObjectSP GetObjectForDotSeparatedPath(llvm::StringRef path);
void DumpToStdout(bool pretty_print = true) const;
virtual void Dump(Stream &s, bool pretty_print = true) const = 0;
private:
lldb::StructuredDataType m_type;
};
class Array : public Object {
public:
Array() : Object(lldb::eStructuredDataTypeArray) {}
~Array() override = default;
bool
ForEach(std::function<bool(Object *object)> const &foreach_callback) const {
for (const auto &object_sp : m_items) {
if (foreach_callback(object_sp.get()) == false)
return false;
}
return true;
}
size_t GetSize() const { return m_items.size(); }
ObjectSP operator[](size_t idx) {
if (idx < m_items.size())
return m_items[idx];
return ObjectSP();
}
ObjectSP GetItemAtIndex(size_t idx) const {
assert(idx < GetSize());
if (idx < m_items.size())
return m_items[idx];
return ObjectSP();
}
template <class IntType>
bool GetItemAtIndexAsInteger(size_t idx, IntType &result) const {
ObjectSP value_sp = GetItemAtIndex(idx);
if (value_sp.get()) {
if (auto int_value = value_sp->GetAsInteger()) {
result = static_cast<IntType>(int_value->GetValue());
return true;
}
}
return false;
}
template <class IntType>
bool GetItemAtIndexAsInteger(size_t idx, IntType &result,
IntType default_val) const {
bool success = GetItemAtIndexAsInteger(idx, result);
if (!success)
result = default_val;
return success;
}
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result) const {
ObjectSP value_sp = GetItemAtIndex(idx);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
result = string_value->GetValue();
return true;
}
}
return false;
}
bool GetItemAtIndexAsString(size_t idx, llvm::StringRef &result,
llvm::StringRef default_val) const {
bool success = GetItemAtIndexAsString(idx, result);
if (!success)
result = default_val;
return success;
}
bool GetItemAtIndexAsString(size_t idx, ConstString &result) const {
ObjectSP value_sp = GetItemAtIndex(idx);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
result = ConstString(string_value->GetValue());
return true;
}
}
return false;
}
bool GetItemAtIndexAsString(size_t idx, ConstString &result,
const char *default_val) const {
bool success = GetItemAtIndexAsString(idx, result);
if (!success)
result.SetCString(default_val);
return success;
}
bool GetItemAtIndexAsDictionary(size_t idx, Dictionary *&result) const {
result = nullptr;
ObjectSP value_sp = GetItemAtIndex(idx);
if (value_sp.get()) {
result = value_sp->GetAsDictionary();
return (result != nullptr);
}
return false;
}
bool GetItemAtIndexAsArray(size_t idx, Array *&result) const {
result = nullptr;
ObjectSP value_sp = GetItemAtIndex(idx);
if (value_sp.get()) {
result = value_sp->GetAsArray();
return (result != nullptr);
}
return false;
}
void Push(ObjectSP item) { m_items.push_back(item); }
void AddItem(ObjectSP item) { m_items.push_back(item); }
void Dump(Stream &s, bool pretty_print = true) const override;
protected:
typedef std::vector<ObjectSP> collection;
collection m_items;
};
class Integer : public Object {
public:
Integer(uint64_t i = 0)
: Object(lldb::eStructuredDataTypeInteger), m_value(i) {}
~Integer() override = default;
void SetValue(uint64_t value) { m_value = value; }
uint64_t GetValue() { return m_value; }
void Dump(Stream &s, bool pretty_print = true) const override;
protected:
uint64_t m_value;
};
class Float : public Object {
public:
Float(double d = 0.0)
: Object(lldb::eStructuredDataTypeFloat), m_value(d) {}
~Float() override = default;
void SetValue(double value) { m_value = value; }
double GetValue() { return m_value; }
void Dump(Stream &s, bool pretty_print = true) const override;
protected:
double m_value;
};
class Boolean : public Object {
public:
Boolean(bool b = false)
: Object(lldb::eStructuredDataTypeBoolean), m_value(b) {}
~Boolean() override = default;
void SetValue(bool value) { m_value = value; }
bool GetValue() { return m_value; }
void Dump(Stream &s, bool pretty_print = true) const override;
protected:
bool m_value;
};
class String : public Object {
public:
String() : Object(lldb::eStructuredDataTypeString) {}
explicit String(llvm::StringRef S)
: Object(lldb::eStructuredDataTypeString), m_value(S) {}
void SetValue(llvm::StringRef S) { m_value = S; }
llvm::StringRef GetValue() { return m_value; }
void Dump(Stream &s, bool pretty_print = true) const override;
protected:
std::string m_value;
};
class Dictionary : public Object {
public:
Dictionary() : Object(lldb::eStructuredDataTypeDictionary), m_dict() {}
~Dictionary() override = default;
size_t GetSize() const { return m_dict.size(); }
void ForEach(std::function<bool(ConstString key, Object *object)> const
&callback) const {
for (const auto &pair : m_dict) {
if (callback(pair.first, pair.second.get()) == false)
break;
}
}
ObjectSP GetKeys() const {
auto object_sp = std::make_shared<Array>();
collection::const_iterator iter;
for (iter = m_dict.begin(); iter != m_dict.end(); ++iter) {
auto key_object_sp = std::make_shared<String>();
key_object_sp->SetValue(iter->first.AsCString());
object_sp->Push(key_object_sp);
}
return object_sp;
}
ObjectSP GetValueForKey(llvm::StringRef key) const {
ObjectSP value_sp;
if (!key.empty()) {
ConstString key_cs(key);
collection::const_iterator iter = m_dict.find(key_cs);
if (iter != m_dict.end())
value_sp = iter->second;
}
return value_sp;
}
bool GetValueForKeyAsBoolean(llvm::StringRef key, bool &result) const {
bool success = false;
ObjectSP value_sp = GetValueForKey(key);
if (value_sp.get()) {
Boolean *result_ptr = value_sp->GetAsBoolean();
if (result_ptr) {
result = result_ptr->GetValue();
success = true;
}
}
return success;
}
template <class IntType>
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const {
ObjectSP value_sp = GetValueForKey(key);
if (value_sp) {
if (auto int_value = value_sp->GetAsInteger()) {
result = static_cast<IntType>(int_value->GetValue());
return true;
}
}
return false;
}
template <class IntType>
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result,
IntType default_val) const {
bool success = GetValueForKeyAsInteger<IntType>(key, result);
if (!success)
result = default_val;
return success;
}
bool GetValueForKeyAsString(llvm::StringRef key,
llvm::StringRef &result) const {
ObjectSP value_sp = GetValueForKey(key);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
result = string_value->GetValue();
return true;
}
}
return false;
}
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result,
const char *default_val) const {
bool success = GetValueForKeyAsString(key, result);
if (!success) {
if (default_val)
result = default_val;
else
result = llvm::StringRef();
}
return success;
}
bool GetValueForKeyAsString(llvm::StringRef key,
ConstString &result) const {
ObjectSP value_sp = GetValueForKey(key);
if (value_sp.get()) {
if (auto string_value = value_sp->GetAsString()) {
result = ConstString(string_value->GetValue());
return true;
}
}
return false;
}
bool GetValueForKeyAsString(llvm::StringRef key, ConstString &result,
const char *default_val) const {
bool success = GetValueForKeyAsString(key, result);
if (!success)
result.SetCString(default_val);
return success;
}
bool GetValueForKeyAsDictionary(llvm::StringRef key,
Dictionary *&result) const {
result = nullptr;
ObjectSP value_sp = GetValueForKey(key);
if (value_sp.get()) {
result = value_sp->GetAsDictionary();
return (result != nullptr);
}
return false;
}
bool GetValueForKeyAsArray(llvm::StringRef key, Array *&result) const {
result = nullptr;
ObjectSP value_sp = GetValueForKey(key);
if (value_sp.get()) {
result = value_sp->GetAsArray();
return (result != nullptr);
}
return false;
}
bool HasKey(llvm::StringRef key) const {
ConstString key_cs(key);
collection::const_iterator search = m_dict.find(key_cs);
return search != m_dict.end();
}
void AddItem(llvm::StringRef key, ObjectSP value_sp) {
ConstString key_cs(key);
m_dict[key_cs] = value_sp;
}
void AddIntegerItem(llvm::StringRef key, uint64_t value) {
AddItem(key, std::make_shared<Integer>(value));
}
void AddFloatItem(llvm::StringRef key, double value) {
AddItem(key, std::make_shared<Float>(value));
}
void AddStringItem(llvm::StringRef key, llvm::StringRef value) {
AddItem(key, std::make_shared<String>(std::move(value)));
}
void AddBooleanItem(llvm::StringRef key, bool value) {
AddItem(key, std::make_shared<Boolean>(value));
}
void Dump(Stream &s, bool pretty_print = true) const override;
protected:
typedef std::map<ConstString, ObjectSP> collection;
collection m_dict;
};
class Null : public Object {
public:
Null() : Object(lldb::eStructuredDataTypeNull) {}
~Null() override = default;
bool IsValid() const override { return false; }
void Dump(Stream &s, bool pretty_print = true) const override;
};
class Generic : public Object {
public:
explicit Generic(void *object = nullptr)
: Object(lldb::eStructuredDataTypeGeneric), m_object(object) {}
void SetValue(void *value) { m_object = value; }
void *GetValue() const { return m_object; }
bool IsValid() const override { return m_object != nullptr; }
void Dump(Stream &s, bool pretty_print = true) const override;
private:
void *m_object;
};
static ObjectSP ParseJSON(std::string json_text);
static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error);
};
} // namespace lldb_private
#endif // liblldb_StructuredData_h_