| //===-- JSONGenerator.h ----------------------------------------*- C++ -*-===// | |
| // | |
| // The LLVM Compiler Infrastructure | |
| // | |
| // This file is distributed under the University of Illinois Open Source | |
| // License. See LICENSE.TXT for details. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef __JSONGenerator_h_ | |
| #define __JSONGenerator_h_ | |
| // C Includes | |
| // C++ Includes | |
| #include <iomanip> | |
| #include <sstream> | |
| #include <string> | |
| #include <utility> | |
| #include <vector> | |
| //---------------------------------------------------------------------- | |
| /// @class JSONGenerator JSONGenerator.h | |
| /// @brief A class which can construct structured data for the sole purpose | |
| /// of printing it in JSON format. | |
| /// | |
| /// A stripped down version of lldb's StructuredData objects which are much | |
| /// general purpose. This variant is intended only for assembling information | |
| /// and printing it as a JSON string. | |
| //---------------------------------------------------------------------- | |
| class JSONGenerator | |
| { | |
| 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; | |
| enum class Type | |
| { | |
| eTypeInvalid = -1, | |
| eTypeNull = 0, | |
| eTypeGeneric, | |
| eTypeArray, | |
| eTypeInteger, | |
| eTypeFloat, | |
| eTypeBoolean, | |
| eTypeString, | |
| eTypeDictionary | |
| }; | |
| class Object : | |
| public std::enable_shared_from_this<Object> | |
| { | |
| public: | |
| Object (Type t = Type::eTypeInvalid) : | |
| m_type (t) | |
| { | |
| } | |
| virtual ~Object () | |
| { | |
| } | |
| virtual bool | |
| IsValid() const | |
| { | |
| return true; | |
| } | |
| virtual void | |
| Clear () | |
| { | |
| m_type = Type::eTypeInvalid; | |
| } | |
| Type | |
| GetType () const | |
| { | |
| return m_type; | |
| } | |
| void | |
| SetType (Type t) | |
| { | |
| m_type = t; | |
| } | |
| Array * | |
| GetAsArray () | |
| { | |
| if (m_type == Type::eTypeArray) | |
| return (Array *)this; | |
| return NULL; | |
| } | |
| Dictionary * | |
| GetAsDictionary () | |
| { | |
| if (m_type == Type::eTypeDictionary) | |
| return (Dictionary *)this; | |
| return NULL; | |
| } | |
| Integer * | |
| GetAsInteger () | |
| { | |
| if (m_type == Type::eTypeInteger) | |
| return (Integer *)this; | |
| return NULL; | |
| } | |
| Float * | |
| GetAsFloat () | |
| { | |
| if (m_type == Type::eTypeFloat) | |
| return (Float *)this; | |
| return NULL; | |
| } | |
| Boolean * | |
| GetAsBoolean () | |
| { | |
| if (m_type == Type::eTypeBoolean) | |
| return (Boolean *)this; | |
| return NULL; | |
| } | |
| String * | |
| GetAsString () | |
| { | |
| if (m_type == Type::eTypeString) | |
| return (String *)this; | |
| return NULL; | |
| } | |
| Generic * | |
| GetAsGeneric() | |
| { | |
| if (m_type == Type::eTypeGeneric) | |
| return (Generic *)this; | |
| return NULL; | |
| } | |
| virtual void | |
| Dump (std::ostream &s) const = 0; | |
| private: | |
| Type m_type; | |
| }; | |
| class Array : public Object | |
| { | |
| public: | |
| Array () : | |
| Object (Type::eTypeArray) | |
| { | |
| } | |
| virtual | |
| ~Array() | |
| { | |
| } | |
| void | |
| AddItem(ObjectSP item) | |
| { | |
| m_items.push_back(item); | |
| } | |
| void Dump(std::ostream &s) const override | |
| { | |
| s << "["; | |
| const size_t arrsize = m_items.size(); | |
| for (size_t i = 0; i < arrsize; ++i) | |
| { | |
| m_items[i]->Dump(s); | |
| if (i + 1 < arrsize) | |
| s << ","; | |
| } | |
| s << "]"; | |
| } | |
| protected: | |
| typedef std::vector<ObjectSP> collection; | |
| collection m_items; | |
| }; | |
| class Integer : public Object | |
| { | |
| public: | |
| Integer (uint64_t value = 0) : | |
| Object (Type::eTypeInteger), | |
| m_value (value) | |
| { | |
| } | |
| virtual ~Integer() | |
| { | |
| } | |
| void | |
| SetValue (uint64_t value) | |
| { | |
| m_value = value; | |
| } | |
| void Dump(std::ostream &s) const override | |
| { | |
| s << m_value; | |
| } | |
| protected: | |
| uint64_t m_value; | |
| }; | |
| class Float : public Object | |
| { | |
| public: | |
| Float (double d = 0.0) : | |
| Object (Type::eTypeFloat), | |
| m_value (d) | |
| { | |
| } | |
| virtual ~Float() | |
| { | |
| } | |
| void | |
| SetValue (double value) | |
| { | |
| m_value = value; | |
| } | |
| void Dump(std::ostream &s) const override | |
| { | |
| s << m_value; | |
| } | |
| protected: | |
| double m_value; | |
| }; | |
| class Boolean : public Object | |
| { | |
| public: | |
| Boolean (bool b = false) : | |
| Object (Type::eTypeBoolean), | |
| m_value (b) | |
| { | |
| } | |
| virtual ~Boolean() | |
| { | |
| } | |
| void | |
| SetValue (bool value) | |
| { | |
| m_value = value; | |
| } | |
| void Dump(std::ostream &s) const override | |
| { | |
| if (m_value == true) | |
| s << "true"; | |
| else | |
| s << "false"; | |
| } | |
| protected: | |
| bool m_value; | |
| }; | |
| class String : public Object | |
| { | |
| public: | |
| String () : | |
| Object (Type::eTypeString), | |
| m_value () | |
| { | |
| } | |
| String (const std::string &s) : | |
| Object (Type::eTypeString), | |
| m_value (s) | |
| { | |
| } | |
| String (const std::string &&s) : | |
| Object (Type::eTypeString), | |
| m_value (s) | |
| { | |
| } | |
| void | |
| SetValue (const std::string &string) | |
| { | |
| m_value = string; | |
| } | |
| void Dump(std::ostream &s) const override | |
| { | |
| std::string quoted; | |
| const size_t strsize = m_value.size(); | |
| for (size_t i = 0; i < strsize ; ++i) | |
| { | |
| char ch = m_value[i]; | |
| if (ch == '"') | |
| quoted.push_back ('\\'); | |
| quoted.push_back (ch); | |
| } | |
| s << '"' << quoted.c_str() << '"'; | |
| } | |
| protected: | |
| std::string m_value; | |
| }; | |
| class Dictionary : public Object | |
| { | |
| public: | |
| Dictionary () : | |
| Object (Type::eTypeDictionary), | |
| m_dict () | |
| { | |
| } | |
| virtual ~Dictionary() | |
| { | |
| } | |
| void | |
| AddItem (std::string key, ObjectSP value) | |
| { | |
| m_dict.push_back(Pair(key, value)); | |
| } | |
| void | |
| AddIntegerItem (std::string key, uint64_t value) | |
| { | |
| AddItem (key, ObjectSP (new Integer(value))); | |
| } | |
| void | |
| AddFloatItem (std::string key, double value) | |
| { | |
| AddItem (key, ObjectSP (new Float(value))); | |
| } | |
| void | |
| AddStringItem (std::string key, std::string value) | |
| { | |
| AddItem (key, ObjectSP (new String(std::move(value)))); | |
| } | |
| void | |
| AddBytesAsHexASCIIString (std::string key, const uint8_t *src, size_t src_len) | |
| { | |
| if (src && src_len) | |
| { | |
| std::ostringstream strm; | |
| for (size_t i = 0; i < src_len; i++) | |
| strm << std::setfill('0') << std::hex << std::right << std::setw(2) << ((uint32_t)(src[i])); | |
| AddItem (key, ObjectSP (new String(std::move(strm.str())))); | |
| } | |
| else | |
| { | |
| AddItem (key, ObjectSP (new String())); | |
| } | |
| } | |
| void | |
| AddBooleanItem (std::string key, bool value) | |
| { | |
| AddItem (key, ObjectSP (new Boolean(value))); | |
| } | |
| void Dump(std::ostream &s) const override | |
| { | |
| bool have_printed_one_elem = false; | |
| s << "{"; | |
| for (collection::const_iterator iter = m_dict.begin(); iter != m_dict.end(); ++iter) | |
| { | |
| if (have_printed_one_elem == false) | |
| { | |
| have_printed_one_elem = true; | |
| } | |
| else | |
| { | |
| s << ","; | |
| } | |
| s << "\"" << iter->first.c_str() << "\":"; | |
| iter->second->Dump(s); | |
| } | |
| s << "}"; | |
| } | |
| protected: | |
| // Keep the dictionary as a vector so the dictionary doesn't reorder itself when you dump it | |
| // We aren't accessing keys by name, so this won't affect performance | |
| typedef std::pair<std::string, ObjectSP> Pair; | |
| typedef std::vector<Pair> collection; | |
| collection m_dict; | |
| }; | |
| class Null : public Object | |
| { | |
| public: | |
| Null () : | |
| Object (Type::eTypeNull) | |
| { | |
| } | |
| virtual ~Null() | |
| { | |
| } | |
| bool | |
| IsValid() const override | |
| { | |
| return false; | |
| } | |
| void Dump(std::ostream &s) const override | |
| { | |
| s << "null"; | |
| } | |
| protected: | |
| }; | |
| class Generic : public Object | |
| { | |
| public: | |
| explicit Generic(void *object = nullptr) | |
| : Object(Type::eTypeGeneric) | |
| , 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(std::ostream &s) const override; | |
| private: | |
| void *m_object; | |
| }; | |
| }; // class JSONGenerator | |
| #endif // __JSONGenerator_h_ |