Encapsulate RapidJSON dependency and use SAX readers/writers

Author: wravery

JSONResponse.cpp

@@ -3,182 +3,245 @@
 
 #include <graphqlservice/JSONResponse.h>
 
+#define RAPIDJSON_NAMESPACE facebook::graphql::rapidjson
+#define RAPIDJSON_NAMESPACE_BEGIN namespace facebook { namespace graphql { namespace rapidjson {
+#define RAPIDJSON_NAMESPACE_END } /* namespace rapidjson */ } /* namespace graphql */ } /* namespace facebook */
+#include <rapidjson/rapidjson.h>
+
+#include <rapidjson/stringbuffer.h>
+#include <rapidjson/writer.h>
+#include <rapidjson/reader.h>
+
+#include <stack>
+
 namespace facebook {
 namespace graphql {
-namespace rapidjson {
+namespace response {
 
-Value convertResponse(Document::AllocatorType& allocator, response::Value&& response)
+void writeResponse(rapidjson::Writer<rapidjson::StringBuffer>& writer, Value&& response)
 {
 	switch (response.type())
 	{
-		case response::Type::Map:
+		case Type::Map:
 		{
-			Value result(Type::kObjectType);
-			auto members = response.release<response::MapType>();
+			auto members = response.release<MapType>();
+
+			writer.StartObject();
 
 			for (auto& entry : members)
 			{
-				result.AddMember(
-					Value(entry.first.c_str(), static_cast<SizeType>(entry.first.size()), allocator),
-					convertResponse(allocator, std::move(entry.second)), allocator);
+				writer.Key(entry.first.c_str());
+				writeResponse(writer, std::move(entry.second));
 			}
 
-			return result;
+			writer.EndObject();
+			break;
 		}
 
-		case response::Type::List:
+		case Type::List:
 		{
-			Value result(Type::kArrayType);
-			auto elements = response.release<response::ListType>();
+			auto elements = response.release<ListType>();
+
+			writer.StartArray();
 
-			result.Reserve(static_cast<SizeType>(elements.size()), allocator);
 			for (auto& entry : elements)
 			{
-				result.PushBack(convertResponse(allocator, std::move(entry)), allocator);
+				writeResponse(writer, std::move(entry));
 			}
 
-			return result;
+			writer.EndArray();
+			break;
 		}
 
-		case response::Type::String:
-		case response::Type::EnumValue:
+		case Type::String:
+		case Type::EnumValue:
 		{
-			Value result(Type::kStringType);
-			auto value = response.release<response::StringType>();
+			auto value = response.release<StringType>();
 
-			result.SetString(value.c_str(), static_cast<SizeType>(value.size()), allocator);
-
-			return result;
+			writer.String(value.c_str());
+			break;
 		}
 
-		case response::Type::Null:
+		case Type::Null:
 		{
-			Value result(Type::kNullType);
-
-			return result;
+			writer.Null();
+			break;
 		}
 
-		case response::Type::Boolean:
+		case Type::Boolean:
 		{
-			Value result(response.get<response::BooleanType>()
-				? Type::kTrueType
-				: Type::kFalseType);
-
-			return result;
+			writer.Bool(response.get<BooleanType>());
+			break;
 		}
 
-		case response::Type::Int:
+		case Type::Int:
 		{
-			Value result(Type::kNumberType);
-
-			result.SetInt(response.get<response::IntType>());
-
-			return result;
+			writer.Int(response.get<IntType>());
+			break;
 		}
 
-		case response::Type::Float:
+		case Type::Float:
 		{
-			Value result(Type::kNumberType);
-
-			result.SetDouble(response.get<response::FloatType>());
-
-			return result;
+			writer.Double(response.get<FloatType>());
+			break;
 		}
 
-		case response::Type::Scalar:
+		case Type::Scalar:
 		{
-			return convertResponse(allocator, response.release<response::ScalarType>());
+			writeResponse(writer, response.release<ScalarType>());
+			break;
 		}
 
 		default:
 		{
-			return Value(Type::kNullType);
+			writer.Null();
+			break;
 		}
 	}
 }
 
-Document convertResponse(response::Value&& response)
+std::string toJSON(Value&& response)
 {
-	Document document;
-	auto result = convertResponse(document.GetAllocator(), std::move(response));
+	rapidjson::StringBuffer buffer;
+	rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
 
-	static_cast<Value&>(document).Swap(result);
-
-	return document;
+	writeResponse(writer, std::move(response));
+	return buffer.GetString();
 }
 
-
-response::Value convertResponse(const Value& value)
+struct ResponseHandler
+	: rapidjson::BaseReaderHandler<rapidjson::UTF8<>, ResponseHandler>
 {
-	switch (value.GetType())
+	ResponseHandler()
 	{
-		case Type::kNullType:
-			return response::Value();
+		// Start with a single null value.
+		_responseStack.push({});
+	}
 
-		case Type::kFalseType:
-			return response::Value(false);
+	Value getResponse()
+	{
+		auto response = std::move(_responseStack.top());
 
-		case Type::kTrueType:
-			return response::Value(true);
+		_responseStack.pop();
 
-		case Type::kObjectType:
-		{
-			response::Value response(response::Type::Map);
+		return response;
+	}
 
-			response.reserve(static_cast<size_t>(value.MemberCount()));
-			for (const auto& member : value.GetObject())
-			{
-				response.emplace_back(member.name.GetString(),
-					convertResponse(member.value));
-			}
+	bool Null()
+	{
+		setValue(Value());
+		return true;
+	}
 
-			return response;
-		}
+	bool Bool(bool b)
+	{
+		setValue(Value(b));
+		return true;
+	}
 
-		case Type::kArrayType:
-		{
-			response::Value response(response::Type::List);
+	bool Int(int i)
+	{
+		auto value = Value(Type::Int);
 
-			response.reserve(static_cast<size_t>(value.Size()));
-			for (const auto& element : value.GetArray())
-			{
-				response.emplace_back(convertResponse(element));
-			}
+		value.set<IntType>(std::move(i));
+		setValue(std::move(value));
+		return true;
+	}
 
-			return response;
-		}
+	bool Uint(unsigned int i)
+	{
+		return Int(static_cast<int>(i));
+	}
 
-		case Type::kStringType:
-			return response::Value(std::string(value.GetString()));
+	bool Int64(int64_t i)
+	{
+		return Int(static_cast<int>(i));
+	}
 
-		case Type::kNumberType:
+	bool Uint64(uint64_t i)
+	{
+		return Int(static_cast<int>(i));
+	}
+
+	bool Double(double d)
+	{
+		auto value = Value(Type::Float);
+
+		value.set<FloatType>(std::move(d));
+		setValue(std::move(value));
+		return true;
+	}
+
+	bool String(const Ch* str, rapidjson::SizeType /*length*/, bool /*copy*/)
+	{
+		setValue(Value(std::string(str)));
+		return true;
+	}
+
+	bool StartObject()
+	{
+		_responseStack.push(Value(Type::Map));
+		return true;
+	}
+
+	bool Key(const Ch* str, rapidjson::SizeType /*length*/, bool /*copy*/)
+	{
+		_key = str;
+		return true;
+	}
+
+	bool EndObject(rapidjson::SizeType /*count*/)
+	{
+		setValue(getResponse());
+		return true;
+	}
+
+	bool StartArray()
+	{
+		_responseStack.push(Value(Type::List));
+		return true;
+	}
+
+	bool EndArray(rapidjson::SizeType /*count*/)
+	{
+		setValue(getResponse());
+		return true;
+	}
+
+private:
+	void setValue(Value&& value)
+	{
+		switch (_responseStack.top().type())
 		{
-			response::Value response(value.IsInt()
-				? response::Type::Int
-				: response::Type::Float);
+			case Type::Map:
+				_responseStack.top().emplace_back(std::move(_key), std::move(value));
+				break;
 
-			if (value.IsInt())
-			{
-				response.set<response::IntType>(value.GetInt());
-			}
-			else
-			{
-				response.set<response::FloatType>(value.GetDouble());
-			}
+			case Type::List:
+				_responseStack.top().emplace_back(std::move(value));
+				break;
 
-			return response;
+			default:
+				_responseStack.top() = std::move(value);
+				break;
 		}
-
-		default:
-			return response::Value();
 	}
-}
 
-response::Value convertResponse(const Document& document)
+	std::string _key;
+	std::stack<Value> _responseStack;
+};
+
+Value parseJSON(const std::string& json)
 {
-	return convertResponse(static_cast<const Value&>(document));
+	ResponseHandler handler;
+	rapidjson::Reader reader;
+	rapidjson::StringStream ss(json.c_str());
+
+	reader.Parse(ss, handler);
+
+	return handler.getResponse();
 }
 
-} /* namespace rapidjson */
+} /* namespace response */
 } /* namespace graphql */
 } /* namespace facebook */

include/graphqlservice/JSONResponse.h

@@ -5,19 +5,14 @@
 
 #include <graphqlservice/GraphQLResponse.h>
 
-#define RAPIDJSON_NAMESPACE facebook::graphql::rapidjson
-#define RAPIDJSON_NAMESPACE_BEGIN namespace facebook { namespace graphql { namespace rapidjson {
-#define RAPIDJSON_NAMESPACE_END } /* namespace rapidjson */ } /* namespace graphql */ } /* namespace facebook */
-#include <rapidjson/document.h>
-
 namespace facebook {
 namespace graphql {
-namespace rapidjson {
+namespace response {
 
-Document convertResponse(response::Value&& response);
+std::string toJSON(Value&& response);
 
-response::Value convertResponse(const Document& document);
+Value parseJSON(const std::string& json);
 
-} /* namespace rapidjson */
+} /* namespace response */
 } /* namespace graphql */
 } /* namespace facebook */