Export a type erased JSON writer object

Author: wravery

include/graphqlservice/GraphQLResponse.h

@@ -263,6 +263,102 @@ GRAPHQLRESPONSE_EXPORT IdType Value::release<IdType>();
 
 using AwaitableValue = internal::Awaitable<Value>;
 
+class Writer
+{
+private:
+	struct Concept
+	{
+		virtual ~Concept() = default;
+
+		virtual void start_object() const = 0;
+		virtual void add_member(const std::string& key) const = 0;
+		virtual void end_object() const = 0;
+
+		virtual void start_array() const = 0;
+		virtual void end_arrary() const = 0;
+
+		virtual void write_null() const = 0;
+		virtual void write_string(const std::string& value) const = 0;
+		virtual void write_bool(bool value) const = 0;
+		virtual void write_int(int value) const = 0;
+		virtual void write_float(double value) const = 0;
+	};
+
+	template <class T>
+	struct Model : Concept
+	{
+		Model(std::unique_ptr<T>&& pimpl)
+			: _pimpl { std::move(pimpl) }
+		{
+		}
+
+		void start_object() const final
+		{
+			_pimpl->start_object();
+		}
+
+		void add_member(const std::string& key) const final
+		{
+			_pimpl->add_member(key);
+		}
+
+		void end_object() const final
+		{
+			_pimpl->end_object();
+		}
+
+		void start_array() const final
+		{
+			_pimpl->start_array();
+		}
+
+		void end_arrary() const final
+		{
+			_pimpl->end_arrary();
+		}
+
+		void write_null() const final
+		{
+			_pimpl->write_null();
+		}
+
+		void write_string(const std::string& value) const final
+		{
+			_pimpl->write_string(value);
+		}
+
+		void write_bool(bool value) const final
+		{
+			_pimpl->write_bool(value);
+		}
+
+		void write_int(int value) const final
+		{
+			_pimpl->write_int(value);
+		}
+
+		void write_float(double value) const final
+		{
+			_pimpl->write_float(value);
+		}
+
+	private:
+		std::unique_ptr<T> _pimpl;
+	};
+
+	const std::shared_ptr<const Concept> _concept;
+
+public:
+	template <class T>
+	Writer(std::unique_ptr<T> writer)
+		: _concept { std::static_pointer_cast<Concept>(
+			std::make_shared<Model<T>>(std::move(writer))) }
+	{
+	}
+
+	GRAPHQLRESPONSE_EXPORT void write(Value value) const;
+};
+
 } // namespace graphql::response
 
 #endif // GRAPHQLRESPONSE_H

src/GraphQLResponse.cpp

@@ -695,4 +695,86 @@ const Value& Value::operator[](size_t index) const
 	return std::get<ListType>(_data).at(index);
 }
 
+void Writer::write(Value response) const
+{
+	switch (response.type())
+	{
+		case Type::Map:
+		{
+			auto members = response.release<MapType>();
+
+			_concept->start_object();
+
+			for (auto& entry : members)
+			{
+				_concept->add_member(entry.first);
+				write(std::move(entry.second));
+			}
+
+			_concept->end_object();
+			break;
+		}
+
+		case Type::List:
+		{
+			auto elements = response.release<ListType>();
+
+			_concept->start_array();
+
+			for (auto& entry : elements)
+			{
+				write(std::move(entry));
+			}
+
+			_concept->end_arrary();
+			break;
+		}
+
+		case Type::String:
+		case Type::EnumValue:
+		{
+			auto value = response.release<StringType>();
+
+			_concept->write_string(value);
+			break;
+		}
+
+		case Type::Null:
+		{
+			_concept->write_null();
+			break;
+		}
+
+		case Type::Boolean:
+		{
+			_concept->write_bool(response.get<BooleanType>());
+			break;
+		}
+
+		case Type::Int:
+		{
+			_concept->write_int(response.get<IntType>());
+			break;
+		}
+
+		case Type::Float:
+		{
+			_concept->write_float(response.get<FloatType>());
+			break;
+		}
+
+		case Type::Scalar:
+		{
+			write(response.release<ScalarType>());
+			break;
+		}
+
+		default:
+		{
+			_concept->write_null();
+			break;
+		}
+	}
+}
+
 } // namespace graphql::response

src/JSONResponse.cpp

@@ -16,94 +16,74 @@
 
 namespace graphql::response {
 
-void writeResponse(rapidjson::Writer<rapidjson::StringBuffer>& writer, Value&& response)
+class StringWriter
 {
-	switch (response.type())
+public:
+	StringWriter(rapidjson::StringBuffer& buffer)
+		: _writer { buffer }
 	{
-		case Type::Map:
-		{
-			auto members = response.release<MapType>();
-
-			writer.StartObject();
-
-			for (auto& entry : members)
-			{
-				writer.Key(entry.first.c_str());
-				writeResponse(writer, std::move(entry.second));
-			}
-
-			writer.EndObject();
-			break;
-		}
-
-		case Type::List:
-		{
-			auto elements = response.release<ListType>();
-
-			writer.StartArray();
+	}
 
-			for (auto& entry : elements)
-			{
-				writeResponse(writer, std::move(entry));
-			}
+	void start_object()
+	{
+		_writer.StartObject();
+	}
 
-			writer.EndArray();
-			break;
-		}
+	void add_member(const std::string& key)
+	{
+		_writer.Key(key.c_str());
+	}
 
-		case Type::String:
-		case Type::EnumValue:
-		{
-			auto value = response.release<StringType>();
+	void end_object()
+	{
+		_writer.EndObject();
+	}
 
-			writer.String(value.c_str());
-			break;
-		}
+	void start_array()
+	{
+		_writer.StartArray();
+	}
 
-		case Type::Null:
-		{
-			writer.Null();
-			break;
-		}
+	void end_arrary()
+	{
+		_writer.EndArray();
+	}
 
-		case Type::Boolean:
-		{
-			writer.Bool(response.get<BooleanType>());
-			break;
-		}
+	void write_null()
+	{
+		_writer.Null();
+	}
 
-		case Type::Int:
-		{
-			writer.Int(response.get<IntType>());
-			break;
-		}
+	void write_string(const std::string& value)
+	{
+		_writer.String(value.c_str());
+	}
 
-		case Type::Float:
-		{
-			writer.Double(response.get<FloatType>());
-			break;
-		}
+	void write_bool(bool value)
+	{
+		_writer.Bool(value);
+	}
 
-		case Type::Scalar:
-		{
-			writeResponse(writer, response.release<ScalarType>());
-			break;
-		}
+	void write_int(int value)
+	{
+		_writer.Int(value);
+	}
 
-		default:
-		{
-			writer.Null();
-			break;
-		}
+	void write_float(double value)
+	{
+		_writer.Double(value);
 	}
-}
+
+private:
+	rapidjson::Writer<rapidjson::StringBuffer> _writer;
+};
 
 std::string toJSON(Value&& response)
 {
 	rapidjson::StringBuffer buffer;
-	rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+	Writer writer { std::make_unique<StringWriter>(buffer) };
 
-	writeResponse(writer, std::move(response));
+	writer.write(std::move(response));
 	return buffer.GetString();
 }