Use a string_view for ast strings as much as possible

wravery · wravery · commit 4752226c0865 · 2020-12-17T17:08:51.000-08:00
diff --git a/include/Validation.h b/include/Validation.h
@@ -79,15 +79,15 @@ struct ValidateArgumentMap
 };
 
 using ValidateArgumentVariant = std::variant<ValidateArgumentVariable, response::IntType,
-	response::FloatType, response::StringType, response::BooleanType, ValidateArgumentEnumValue,
+	response::FloatType, std::string_view, response::BooleanType, ValidateArgumentEnumValue,
 	ValidateArgumentList, ValidateArgumentMap>;
 
 struct ValidateArgumentValue
 {
 	ValidateArgumentValue(ValidateArgumentVariable&& value);
 	ValidateArgumentValue(response::IntType value);
 	ValidateArgumentValue(response::FloatType value);
-	ValidateArgumentValue(response::StringType&& value);
+	ValidateArgumentValue(std::string_view value);
 	ValidateArgumentValue(response::BooleanType value);
 	ValidateArgumentValue(ValidateArgumentEnumValue&& value);
 	ValidateArgumentValue(ValidateArgumentList&& value);
diff --git a/include/graphqlservice/GraphQLTree.h b/include/graphqlservice/GraphQLTree.h
@@ -12,6 +12,7 @@
 #include <tao/pegtl/contrib/parse_tree.hpp>
 
 #include <string>
+#include <string_view>
 #include <variant>
 #include <vector>
 
@@ -21,7 +22,9 @@ using namespace tao::graphqlpeg;
 
 struct ast_node : parse_tree::basic_node<ast_node>
 {
-	std::string unescaped;
+	std::string_view unescaped_view() const;
+
+	std::variant<std::string_view, std::string> unescaped;
 };
 
 struct ast_input
diff --git a/src/GraphQLService.cpp b/src/GraphQLService.cpp
@@ -253,7 +253,7 @@ void ValueVisitor::visitFloatValue(const peg::ast_node& floatValue)
 
 void ValueVisitor::visitStringValue(const peg::ast_node& stringValue)
 {
-	_value = response::Value(std::string(stringValue.unescaped));
+	_value = response::Value(std::string { stringValue.unescaped_view() });
 }
 
 void ValueVisitor::visitBooleanValue(const peg::ast_node& booleanValue)
diff --git a/src/GraphQLTree.cpp b/src/GraphQLTree.cpp
@@ -12,9 +12,20 @@
 #include <numeric>
 #include <tuple>
 
+using namespace std::literals;
+
 namespace graphql {
 namespace peg {
 
+std::string_view ast_node::unescaped_view() const
+{
+	return std::visit(
+		[](const auto& value) noexcept {
+			return std::string_view { value };
+		},
+		unescaped);
+}
+
 using namespace tao::graphqlpeg;
 
 template <typename Rule>
@@ -69,12 +80,18 @@ struct ast_selector<escaped_unicode> : std::true_type
 	{
 		if (n->has_content())
 		{
+			auto unescaped = std::visit(
+				[](auto&& unescaped) noexcept {
+					return std::string { std::move(unescaped) };
+				},
+				std::move(n->unescaped));
 			auto content = n->string_view();
 
-			if (unescape::utf8_append_utf32(n->unescaped,
+			if (unescape::utf8_append_utf32(unescaped,
 					unescape::unhex_string<uint32_t>(content.data() + 1,
 						content.data() + content.size())))
 			{
+				n->unescaped = std::move(unescaped);
 				return;
 			}
 		}
@@ -95,35 +112,35 @@ struct ast_selector<escaped_char> : std::true_type
 			switch (ch)
 			{
 				case '"':
-					n->unescaped = "\"";
+					n->unescaped = "\""sv;
 					return;
 
 				case '\\':
-					n->unescaped = "\\";
+					n->unescaped = "\\"sv;
 					return;
 
 				case '/':
-					n->unescaped = "/";
+					n->unescaped = "/"sv;
 					return;
 
 				case 'b':
-					n->unescaped = "\b";
+					n->unescaped = "\b"sv;
 					return;
 
 				case 'f':
-					n->unescaped = "\f";
+					n->unescaped = "\f"sv;
 					return;
 
 				case 'n':
-					n->unescaped = "\n";
+					n->unescaped = "\n"sv;
 					return;
 
 				case 'r':
-					n->unescaped = "\r";
+					n->unescaped = "\r"sv;
 					return;
 
 				case 't':
-					n->unescaped = "\t";
+					n->unescaped = "\t"sv;
 					return;
 
 				default:
@@ -149,7 +166,7 @@ struct ast_selector<block_escape_sequence> : std::true_type
 {
 	static void transform(std::unique_ptr<ast_node>& n)
 	{
-		n->unescaped = R"bq(""")bq";
+		n->unescaped = R"bq(""")bq"sv;
 	}
 };
 
@@ -171,17 +188,21 @@ struct ast_selector<string_value> : std::true_type
 		{
 			if (n->children.size() > 1)
 			{
-				n->unescaped.reserve(std::accumulate(n->children.cbegin(),
+				std::string unescaped;
+
+				unescaped.reserve(std::accumulate(n->children.cbegin(),
 					n->children.cend(),
 					size_t(0),
 					[](size_t total, const std::unique_ptr<ast_node>& child) {
-						return total + child->unescaped.size();
+						return total + child->unescaped_view().size();
 					}));
 
 				for (const auto& child : n->children)
 				{
-					n->unescaped.append(child->unescaped);
+					unescaped.append(child->unescaped_view());
 				}
+
+				n->unescaped = std::move(unescaped);
 			}
 			else
 			{
diff --git a/src/SchemaGenerator.cpp b/src/SchemaGenerator.cpp
@@ -812,7 +812,7 @@ void Generator::visitObjectTypeDefinition(const peg::ast_node& objectTypeDefinit
 		[&description](const peg::ast_node& child) {
 			if (!child.children.empty())
 			{
-				description = child.children.front()->unescaped;
+				description = child.children.front()->unescaped_view();
 			}
 		});
 
@@ -874,7 +874,7 @@ void Generator::visitInterfaceTypeDefinition(const peg::ast_node& interfaceTypeD
 		[&description](const peg::ast_node& child) {
 			if (!child.children.empty())
 			{
-				description = child.children.front()->unescaped;
+				description = child.children.front()->unescaped_view();
 			}
 		});
 
@@ -931,7 +931,7 @@ void Generator::visitInputObjectTypeDefinition(const peg::ast_node& inputObjectT
 		[&description](const peg::ast_node& child) {
 			if (!child.children.empty())
 			{
-				description = child.children.front()->unescaped;
+				description = child.children.front()->unescaped_view();
 			}
 		});
 
@@ -987,7 +987,7 @@ void Generator::visitEnumTypeDefinition(const peg::ast_node& enumTypeDefinition)
 		[&description](const peg::ast_node& child) {
 			if (!child.children.empty())
 			{
-				description = child.children.front()->unescaped;
+				description = child.children.front()->unescaped_view();
 			}
 		});
 
@@ -1029,7 +1029,7 @@ void Generator::visitEnumTypeExtension(const peg::ast_node& enumTypeExtension)
 				[&value](const peg::ast_node& description) {
 					if (!description.children.empty())
 					{
-						value.description = description.children.front()->unescaped;
+						value.description = description.children.front()->unescaped_view();
 					}
 				});
 
@@ -1063,7 +1063,7 @@ void Generator::visitEnumTypeExtension(const peg::ast_node& enumTypeExtension)
 												peg::on_first_child<peg::string_value>(argument,
 													[&value](const peg::ast_node& argumentValue) {
 														value.deprecationReason =
-															argumentValue.unescaped;
+															argumentValue.unescaped_view();
 													});
 											}
 										});
@@ -1092,7 +1092,7 @@ void Generator::visitScalarTypeDefinition(const peg::ast_node& scalarTypeDefinit
 		[&description](const peg::ast_node& child) {
 			if (!child.children.empty())
 			{
-				description = child.children.front()->unescaped;
+				description = child.children.front()->unescaped_view();
 			}
 		});
 
@@ -1115,7 +1115,7 @@ void Generator::visitUnionTypeDefinition(const peg::ast_node& unionTypeDefinitio
 		[&description](const peg::ast_node& child) {
 			if (!child.children.empty())
 			{
-				description = child.children.front()->unescaped;
+				description = child.children.front()->unescaped_view();
 			}
 		});
 
@@ -1164,7 +1164,7 @@ void Generator::visitDirectiveDefinition(const peg::ast_node& directiveDefinitio
 		[&directive](const peg::ast_node& child) {
 			if (!child.children.empty())
 			{
-				directive.description = child.children.front()->unescaped;
+				directive.description = child.children.front()->unescaped_view();
 			}
 		});
 
@@ -1242,7 +1242,7 @@ OutputFieldList Generator::getOutputFields(
 			}
 			else if (child->is_type<peg::description>() && !child->children.empty())
 			{
-				field.description = child->children.front()->unescaped;
+				field.description = child->children.front()->unescaped_view();
 			}
 			else if (child->is_type<peg::directives>())
 			{
@@ -1275,7 +1275,7 @@ OutputFieldList Generator::getOutputFields(
 												peg::on_first_child<peg::string_value>(argument,
 													[&deprecationReason](
 														const peg::ast_node& reason) {
-														deprecationReason = reason.unescaped;
+														deprecationReason = reason.unescaped_view();
 													});
 											}
 										});
@@ -1330,7 +1330,7 @@ InputFieldList Generator::getInputFields(const std::vector<std::unique_ptr<peg::
 			}
 			else if (child->is_type<peg::description>() && !child->children.empty())
 			{
-				field.description = child->children.front()->unescaped;
+				field.description = child->children.front()->unescaped_view();
 			}
 		}
 
@@ -1455,7 +1455,7 @@ void Generator::DefaultValueVisitor::visitFloatValue(const peg::ast_node& floatV
 
 void Generator::DefaultValueVisitor::visitStringValue(const peg::ast_node& stringValue)
 {
-	_value = response::Value(std::string(stringValue.unescaped));
+	_value = response::Value(std::string { stringValue.unescaped_view() });
 }
 
 void Generator::DefaultValueVisitor::visitBooleanValue(const peg::ast_node& booleanValue)
@@ -2593,7 +2593,8 @@ Operations::Operations()cpp";
 			{
 				bool firstValue = true;
 
-				sourceFile << R"cpp(	type)cpp" << unionType.cppType << R"cpp(->AddPossibleTypes({
+				sourceFile << R"cpp(	type)cpp" << unionType.cppType
+						   << R"cpp(->AddPossibleTypes({
 )cpp";
 
 				for (const auto& unionOption : unionType.options)
diff --git a/src/Validation.cpp b/src/Validation.cpp
@@ -71,7 +71,7 @@ ValidateArgumentValue::ValidateArgumentValue(response::FloatType value)
 {
 }
 
-ValidateArgumentValue::ValidateArgumentValue(response::StringType&& value)
+ValidateArgumentValue::ValidateArgumentValue(std::string_view value)
 	: data(std::move(value))
 {
 }
@@ -177,10 +177,10 @@ void ValidateArgumentValueVisitor::visitFloatValue(const peg::ast_node& floatVal
 
 void ValidateArgumentValueVisitor::visitStringValue(const peg::ast_node& stringValue)
 {
-	response::StringType value { stringValue.unescaped };
+	std::string_view value { stringValue.unescaped_view() };
 	auto position = stringValue.begin();
 
-	_argumentValue.value = std::make_unique<ValidateArgumentValue>(std::move(value));
+	_argumentValue.value = std::make_unique<ValidateArgumentValue>(value);
 	_argumentValue.position = { position.line, position.column };
 }
 
@@ -1161,19 +1161,19 @@ bool ValidateExecutableVisitor::validateInputValue(
 			}
 			else if (name == R"gql(String)gql"sv)
 			{
-				if (!std::holds_alternative<response::StringType>(argument.value->data))
+				if (!std::holds_alternative<std::string_view>(argument.value->data))
 				{
 					_errors.push_back({ "Expected String value", argument.position });
 					return false;
 				}
 			}
 			else if (name == R"gql(ID)gql"sv)
 			{
-				if (std::holds_alternative<response::StringType>(argument.value->data))
+				if (std::holds_alternative<std::string_view>(argument.value->data))
 				{
 					try
 					{
-						const auto& value = std::get<response::StringType>(argument.value->data);
+						const auto value = std::get<std::string_view>(argument.value->data);
 						auto decoded = Base64::fromBase64(value.data(), value.size());
 
 						return true;

Original file line number	Diff line number	Diff line change
`@@ -253,7 +253,7 @@ void ValueVisitor::visitFloatValue(const peg::ast_node& floatValue)`
`253`	`253`
`254`	`254`	`void ValueVisitor::visitStringValue(const peg::ast_node& stringValue)`
`255`	`255`	`{`
`256`		`- _value = response::Value(std::string(stringValue.unescaped));`
	`256`	`+ _value = response::Value(std::string { stringValue.unescaped_view() });`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`void ValueVisitor::visitBooleanValue(const peg::ast_node& booleanValue)`
Original file line number	Diff line number	Diff line change
`@@ -812,7 +812,7 @@ void Generator::visitObjectTypeDefinition(const peg::ast_node& objectTypeDefinit`
`812`	`812`	`[&description](const peg::ast_node& child) {`
`813`	`813`	`if (!child.children.empty())`
`814`	`814`	`{`
`815`		`- description = child.children.front()->unescaped;`
	`815`	`+ description = child.children.front()->unescaped_view();`
`816`	`816`	`}`
`817`	`817`	`});`
`818`	`818`
`@@ -874,7 +874,7 @@ void Generator::visitInterfaceTypeDefinition(const peg::ast_node& interfaceTypeD`
`874`	`874`	`[&description](const peg::ast_node& child) {`
`875`	`875`	`if (!child.children.empty())`
`876`	`876`	`{`
`877`		`- description = child.children.front()->unescaped;`
	`877`	`+ description = child.children.front()->unescaped_view();`
`878`	`878`	`}`
`879`	`879`	`});`
`880`	`880`
`@@ -931,7 +931,7 @@ void Generator::visitInputObjectTypeDefinition(const peg::ast_node& inputObjectT`
`931`	`931`	`[&description](const peg::ast_node& child) {`
`932`	`932`	`if (!child.children.empty())`
`933`	`933`	`{`
`934`		`- description = child.children.front()->unescaped;`
	`934`	`+ description = child.children.front()->unescaped_view();`
`935`	`935`	`}`
`936`	`936`	`});`
`937`	`937`
`@@ -987,7 +987,7 @@ void Generator::visitEnumTypeDefinition(const peg::ast_node& enumTypeDefinition)`
`987`	`987`	`[&description](const peg::ast_node& child) {`
`988`	`988`	`if (!child.children.empty())`
`989`	`989`	`{`
`990`		`- description = child.children.front()->unescaped;`
	`990`	`+ description = child.children.front()->unescaped_view();`
`991`	`991`	`}`
`992`	`992`	`});`
`993`	`993`
`@@ -1029,7 +1029,7 @@ void Generator::visitEnumTypeExtension(const peg::ast_node& enumTypeExtension)`
`1029`	`1029`	`[&value](const peg::ast_node& description) {`
`1030`	`1030`	`if (!description.children.empty())`
`1031`	`1031`	`{`
`1032`		`- value.description = description.children.front()->unescaped;`
	`1032`	`+ value.description = description.children.front()->unescaped_view();`
`1033`	`1033`	`}`
`1034`	`1034`	`});`
`1035`	`1035`
`@@ -1063,7 +1063,7 @@ void Generator::visitEnumTypeExtension(const peg::ast_node& enumTypeExtension)`
`1063`	`1063`	`peg::on_first_child<peg::string_value>(argument,`
`1064`	`1064`	`[&value](const peg::ast_node& argumentValue) {`
`1065`	`1065`	`value.deprecationReason =`
`1066`		`- argumentValue.unescaped;`
	`1066`	`+ argumentValue.unescaped_view();`
`1067`	`1067`	`});`
`1068`	`1068`	`}`
`1069`	`1069`	`});`
`@@ -1092,7 +1092,7 @@ void Generator::visitScalarTypeDefinition(const peg::ast_node& scalarTypeDefinit`
`1092`	`1092`	`[&description](const peg::ast_node& child) {`
`1093`	`1093`	`if (!child.children.empty())`
`1094`	`1094`	`{`
`1095`		`- description = child.children.front()->unescaped;`
	`1095`	`+ description = child.children.front()->unescaped_view();`
`1096`	`1096`	`}`
`1097`	`1097`	`});`
`1098`	`1098`
`@@ -1115,7 +1115,7 @@ void Generator::visitUnionTypeDefinition(const peg::ast_node& unionTypeDefinitio`
`1115`	`1115`	`[&description](const peg::ast_node& child) {`
`1116`	`1116`	`if (!child.children.empty())`
`1117`	`1117`	`{`
`1118`		`- description = child.children.front()->unescaped;`
	`1118`	`+ description = child.children.front()->unescaped_view();`
`1119`	`1119`	`}`
`1120`	`1120`	`});`
`1121`	`1121`
`@@ -1164,7 +1164,7 @@ void Generator::visitDirectiveDefinition(const peg::ast_node& directiveDefinitio`
`1164`	`1164`	`[&directive](const peg::ast_node& child) {`
`1165`	`1165`	`if (!child.children.empty())`
`1166`	`1166`	`{`
`1167`		`- directive.description = child.children.front()->unescaped;`
	`1167`	`+ directive.description = child.children.front()->unescaped_view();`
`1168`	`1168`	`}`
`1169`	`1169`	`});`
`1170`	`1170`
`@@ -1242,7 +1242,7 @@ OutputFieldList Generator::getOutputFields(`
`1242`	`1242`	`}`
`1243`	`1243`	`else if (child->is_type<peg::description>() && !child->children.empty())`
`1244`	`1244`	`{`
`1245`		`- field.description = child->children.front()->unescaped;`
	`1245`	`+ field.description = child->children.front()->unescaped_view();`
`1246`	`1246`	`}`
`1247`	`1247`	`else if (child->is_type<peg::directives>())`
`1248`	`1248`	`{`
`@@ -1275,7 +1275,7 @@ OutputFieldList Generator::getOutputFields(`
`1275`	`1275`	`peg::on_first_child<peg::string_value>(argument,`
`1276`	`1276`	`[&deprecationReason](`
`1277`	`1277`	`const peg::ast_node& reason) {`
`1278`		`- deprecationReason = reason.unescaped;`
	`1278`	`+ deprecationReason = reason.unescaped_view();`
`1279`	`1279`	`});`
`1280`	`1280`	`}`
`1281`	`1281`	`});`
`@@ -1330,7 +1330,7 @@ InputFieldList Generator::getInputFields(const std::vector<std::unique_ptr<peg::`
`1330`	`1330`	`}`
`1331`	`1331`	`else if (child->is_type<peg::description>() && !child->children.empty())`
`1332`	`1332`	`{`
`1333`		`- field.description = child->children.front()->unescaped;`
	`1333`	`+ field.description = child->children.front()->unescaped_view();`
`1334`	`1334`	`}`
`1335`	`1335`	`}`
`1336`	`1336`
`@@ -1455,7 +1455,7 @@ void Generator::DefaultValueVisitor::visitFloatValue(const peg::ast_node& floatV`
`1455`	`1455`
`1456`	`1456`	`void Generator::DefaultValueVisitor::visitStringValue(const peg::ast_node& stringValue)`
`1457`	`1457`	`{`
`1458`		`- _value = response::Value(std::string(stringValue.unescaped));`
	`1458`	`+ _value = response::Value(std::string { stringValue.unescaped_view() });`
`1459`	`1459`	`}`
`1460`	`1460`
`1461`	`1461`	`void Generator::DefaultValueVisitor::visitBooleanValue(const peg::ast_node& booleanValue)`
`@@ -2593,7 +2593,8 @@ Operations::Operations()cpp";`
`2593`	`2593`	`{`
`2594`	`2594`	`bool firstValue = true;`
`2595`	`2595`
`2596`		`- sourceFile << R"cpp( type)cpp" << unionType.cppType << R"cpp(->AddPossibleTypes({`
	`2596`	`+ sourceFile << R"cpp( type)cpp" << unionType.cppType`
	`2597`	`+ << R"cpp(->AddPossibleTypes({`
`2597`	`2598`	`)cpp";`
`2598`	`2599`
`2599`	`2600`	`for (const auto& unionOption : unionType.options)`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ ValidateArgumentValue::ValidateArgumentValue(response::FloatType value)`
`71`	`71`	`{`
`72`	`72`	`}`
`73`	`73`
`74`		`-ValidateArgumentValue::ValidateArgumentValue(response::StringType&& value)`
	`74`	`+ValidateArgumentValue::ValidateArgumentValue(std::string_view value)`
`75`	`75`	`: data(std::move(value))`
`76`	`76`	`{`
`77`	`77`	`}`
`@@ -177,10 +177,10 @@ void ValidateArgumentValueVisitor::visitFloatValue(const peg::ast_node& floatVal`
`177`	`177`
`178`	`178`	`void ValidateArgumentValueVisitor::visitStringValue(const peg::ast_node& stringValue)`
`179`	`179`	`{`
`180`		`- response::StringType value { stringValue.unescaped };`
	`180`	`+ std::string_view value { stringValue.unescaped_view() };`
`181`	`181`	`auto position = stringValue.begin();`
`182`	`182`
`183`		`- _argumentValue.value = std::make_unique<ValidateArgumentValue>(std::move(value));`
	`183`	`+ _argumentValue.value = std::make_unique<ValidateArgumentValue>(value);`
`184`	`184`	`_argumentValue.position = { position.line, position.column };`
`185`	`185`	`}`
`186`	`186`
`@@ -1161,19 +1161,19 @@ bool ValidateExecutableVisitor::validateInputValue(`
`1161`	`1161`	`}`
`1162`	`1162`	`else if (name == R"gql(String)gql"sv)`
`1163`	`1163`	`{`
`1164`		`- if (!std::holds_alternative<response::StringType>(argument.value->data))`
	`1164`	`+ if (!std::holds_alternative<std::string_view>(argument.value->data))`
`1165`	`1165`	`{`
`1166`	`1166`	`_errors.push_back({ "Expected String value", argument.position });`
`1167`	`1167`	`return false;`
`1168`	`1168`	`}`
`1169`	`1169`	`}`
`1170`	`1170`	`else if (name == R"gql(ID)gql"sv)`
`1171`	`1171`	`{`
`1172`		`- if (std::holds_alternative<response::StringType>(argument.value->data))`
	`1172`	`+ if (std::holds_alternative<std::string_view>(argument.value->data))`
`1173`	`1173`	`{`
`1174`	`1174`	`try`
`1175`	`1175`	`{`
`1176`		`- const auto& value = std::get<response::StringType>(argument.value->data);`
	`1176`	`+ const auto value = std::get<std::string_view>(argument.value->data);`
`1177`	`1177`	`auto decoded = Base64::fromBase64(value.data(), value.size());`
`1178`	`1178`
`1179`	`1179`	`return true;`