lldb/tools/debugserver/source/JSONGenerator.h - toolchain/llvm-project - Gitiles

 //===-- 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_
	//===-- 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_