diff options
Diffstat (limited to 'include/lldb/Utility/StructuredData.h')
| -rw-r--r-- | include/lldb/Utility/StructuredData.h | 556 |
1 files changed, 556 insertions, 0 deletions
diff --git a/include/lldb/Utility/StructuredData.h b/include/lldb/Utility/StructuredData.h new file mode 100644 index 000000000000..2ea5fb98e055 --- /dev/null +++ b/include/lldb/Utility/StructuredData.h @@ -0,0 +1,556 @@ +//===-- 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" +/// @brief 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_ |