Fix #149

Author: wravery

include/Validation.h

@@ -24,15 +24,15 @@ struct ValidateArgument
 	ValidateType type;
 };
 
-using ValidateTypeFieldArguments = internal::sorted_map<std::string_view, ValidateArgument>;
+using ValidateTypeFieldArguments = internal::string_view_map<ValidateArgument>;
 
 struct ValidateTypeField
 {
 	ValidateType returnType;
 	ValidateTypeFieldArguments arguments;
 };
 
-using ValidateDirectiveArguments = internal::sorted_map<std::string_view, ValidateArgument>;
+using ValidateDirectiveArguments = internal::string_view_map<ValidateArgument>;
 
 struct ValidateDirective
 {
@@ -75,7 +75,7 @@ struct ValidateArgumentMap
 {
 	bool operator==(const ValidateArgumentMap& other) const;
 
-	internal::sorted_map<std::string_view, ValidateArgumentValuePtr> values;
+	internal::string_view_map<ValidateArgumentValuePtr> values;
 };
 
 using ValidateArgumentVariant = std::variant<ValidateArgumentVariable, response::IntType,
@@ -122,7 +122,7 @@ class ValidateArgumentValueVisitor
 	std::list<schema_error>& _errors;
 };
 
-using ValidateFieldArguments = internal::sorted_map<std::string_view, ValidateArgumentValuePtr>;
+using ValidateFieldArguments = internal::string_view_map<ValidateArgumentValuePtr>;
 
 struct ValidateField
 {
@@ -137,7 +137,7 @@ struct ValidateField
 	ValidateFieldArguments arguments;
 };
 
-using ValidateTypes = internal::sorted_map<std::string_view, ValidateType>;
+using ValidateTypes = internal::string_view_map<ValidateType>;
 
 // ValidateVariableTypeVisitor visits the AST and builds a ValidateType structure representing
 // a variable type in an operation definition as if it came from an Introspection query.
@@ -179,11 +179,11 @@ class ValidateExecutableVisitor
 	static ValidateTypeFieldArguments getArguments(
 		const std::vector<std::shared_ptr<const schema::InputValue>>& args);
 
-	using FieldTypes = internal::sorted_map<std::string_view, ValidateTypeField>;
-	using TypeFields = internal::sorted_map<std::string_view, FieldTypes>;
+	using FieldTypes = internal::string_view_map<ValidateTypeField>;
+	using TypeFields = internal::string_view_map<FieldTypes>;
 	using InputFieldTypes = ValidateTypeFieldArguments;
-	using InputTypeFields = internal::sorted_map<std::string_view, InputFieldTypes>;
-	using EnumValues = internal::sorted_map<std::string_view, internal::sorted_set<std::string_view>>;
+	using InputTypeFields = internal::string_view_map<InputFieldTypes>;
+	using EnumValues = internal::string_view_map<internal::string_view_set>;
 
 	constexpr bool isScalarType(introspection::TypeKind kind);
 
@@ -218,15 +218,16 @@ class ValidateExecutableVisitor
 	const std::shared_ptr<schema::Schema> _schema;
 	std::list<schema_error> _errors;
 
-	using Directives = internal::sorted_map<std::string_view, ValidateDirective>;
-	using ExecutableNodes = internal::sorted_map<std::string_view, std::reference_wrapper<const peg::ast_node>>;
-	using FragmentSet = internal::sorted_set<std::string_view>;
-	using MatchingTypes = internal::sorted_map<std::string_view, internal::sorted_set<std::string_view>>;
-	using ScalarTypes = internal::sorted_set<std::string_view>;
-	using VariableDefinitions = internal::sorted_map<std::string_view, std::reference_wrapper<const peg::ast_node>>;
-	using VariableTypes = internal::sorted_map<std::string_view, ValidateArgument>;
+	using Directives = internal::string_view_map<ValidateDirective>;
+	using AstNodeRef = std::reference_wrapper<const peg::ast_node>;
+	using ExecutableNodes = internal::string_view_map<AstNodeRef>;
+	using FragmentSet = internal::string_view_set;
+	using MatchingTypes = internal::string_view_map<internal::string_view_set>;
+	using ScalarTypes = internal::string_view_set;
+	using VariableDefinitions = internal::string_view_map<AstNodeRef>;
+	using VariableTypes = internal::string_view_map<ValidateArgument>;
 	using OperationVariables = std::optional<VariableTypes>;
-	using VariableSet = internal::sorted_set<std::string_view>;
+	using VariableSet = internal::string_view_set;
 
 	// These members store Introspection schema information which does not change between queries.
 	ValidateTypes _operationTypes;
@@ -252,7 +253,7 @@ class ValidateExecutableVisitor
 	TypeFields _typeFields;
 	InputTypeFields _inputTypeFields;
 	ValidateType _scopedType;
-	internal::sorted_map<std::string_view, ValidateField> _selectionFields;
+	internal::string_view_map<ValidateField> _selectionFields;
 };
 
 } /* namespace graphql::service */

include/graphqlservice/GraphQLSchema.h

@@ -67,7 +67,7 @@ class Schema : public std::enable_shared_from_this<Schema>
 	std::shared_ptr<const ObjectType> _query;
 	std::shared_ptr<const ObjectType> _mutation;
 	std::shared_ptr<const ObjectType> _subscription;
-	internal::sorted_map<std::string_view, size_t> _typeMap;
+	internal::string_view_map<size_t> _typeMap;
 	std::vector<std::pair<std::string_view, std::shared_ptr<const BaseType>>> _types;
 	std::vector<std::shared_ptr<const Directive>> _directives;
 	internal::sorted_map<std::shared_ptr<const BaseType>, std::shared_ptr<const BaseType>>

include/graphqlservice/GraphQLService.h

@@ -243,7 +243,7 @@ class Fragment
 
 // Resolvers for complex types need to be able to find fragment definitions anywhere in
 // the request document by name.
-using FragmentMap = internal::sorted_map<std::string_view, Fragment>;
+using FragmentMap = internal::string_view_map<Fragment>;
 
 // Resolver functors take a set of arguments encoded as members on a JSON object
 // with an optional selection set for complex types and return a JSON value for
@@ -279,7 +279,7 @@ struct ResolverResult
 };
 
 using Resolver = std::function<std::future<ResolverResult>(ResolverParams&&)>;
-using ResolverMap = internal::sorted_map<std::string_view, Resolver>;
+using ResolverMap = internal::string_view_map<Resolver>;
 
 // Binary data and opaque strings like IDs are encoded in Base64.
 class Base64
@@ -498,7 +498,7 @@ GRAPHQLSERVICE_EXPORT response::Value ModifiedArgument<response::Value>::convert
 
 // Each type should handle fragments with type conditions matching its own
 // name and any inheritted interfaces.
-using TypeNames = internal::sorted_set<std::string_view>;
+using TypeNames = internal::string_view_set;
 
 // Object parses argument values, performs variable lookups, expands fragments, evaluates @include
 // and @skip directives, and calls through to the resolver functor for each selected field with
@@ -851,7 +851,7 @@ GRAPHQLSERVICE_EXPORT std::future<ResolverResult> ModifiedResult<Object>::conver
 	FieldResult<std::shared_ptr<Object>>&& result, ResolverParams&& params);
 #endif // GRAPHQL_DLLEXPORTS
 
-using TypeMap = internal::sorted_map<std::string_view, std::shared_ptr<Object>>;
+using TypeMap = internal::string_view_map<std::shared_ptr<Object>>;
 
 // You can still sub-class RequestState and use that in the state parameter to Request::subscribe
 // to add your own state to the service callbacks that you receive while executing the subscription
@@ -1002,7 +1002,7 @@ class Request : public std::enable_shared_from_this<Request>
 	const TypeMap _operations;
 	std::unique_ptr<ValidateExecutableVisitor> _validation;
 	internal::sorted_map<SubscriptionKey, std::shared_ptr<SubscriptionData>> _subscriptions;
-	internal::sorted_map<std::string_view, internal::sorted_set<SubscriptionKey>> _listeners;
+	internal::string_view_map<internal::sorted_set<SubscriptionKey>> _listeners;
 	SubscriptionKey _nextKey = 0;
 };
 

include/graphqlservice/internal/SortedMap.h

@@ -7,14 +7,15 @@
 #define SORTEDMAP_H
 
 #include <algorithm>
+#include <functional>
 #include <initializer_list>
 #include <stdexcept>
 #include <tuple>
 #include <vector>
 
 namespace graphql::internal {
 
-template <class K, class V>
+template <class K, class V, class Compare = std::less<K>>
 class sorted_map
 {
 public:
@@ -29,7 +30,7 @@ class sorted_map
 		: _data { init }
 	{
 		std::sort(_data.begin(), _data.end(), [](const auto& lhs, const auto& rhs) noexcept {
-			return lhs.first < rhs.first;
+			return Compare {}(lhs.first, rhs.first);
 		});
 	}
 
@@ -89,7 +90,7 @@ class sorted_map
 			end(),
 			key,
 			[](sorted_map_key lhs, sorted_map_key rhs) noexcept {
-				return lhs.key < rhs.key;
+				return Compare {}(lhs.key, rhs.key);
 			});
 
 		return itr == itrEnd ? _data.end() : itr;
@@ -111,17 +112,15 @@ class sorted_map
 			_data.end(),
 			key,
 			[](sorted_map_key lhs, sorted_map_key rhs) noexcept {
-				return lhs.key < rhs.key;
+				return Compare {}(lhs.key, rhs.key);
 			});
 
 		if (itr != itrEnd)
 		{
 			return { itr, false };
 		}
 
-		return { _data.emplace(itrEnd,
-					 std::move(key),
-					 V { std::forward<ValueArgs>(args)... }),
+		return { _data.emplace(itrEnd, std::move(key), V { std::forward<ValueArgs>(args)... }),
 			true };
 	}
 
@@ -131,7 +130,7 @@ class sorted_map
 			_data.end(),
 			key,
 			[](sorted_map_key lhs, sorted_map_key rhs) noexcept {
-				return lhs.key < rhs.key;
+				return Compare {}(lhs.key, rhs.key);
 			});
 
 		if (itr == itrEnd)
@@ -163,7 +162,7 @@ class sorted_map
 			_data.end(),
 			key,
 			[](sorted_map_key lhs, sorted_map_key rhs) noexcept {
-				return lhs.key < rhs.key;
+				return Compare {}(lhs.key, rhs.key);
 			});
 
 		if (itr != itrEnd)
@@ -182,7 +181,7 @@ class sorted_map
 			_data.end(),
 			key,
 			[](sorted_map_key lhs, sorted_map_key rhs) noexcept {
-				return lhs.key < rhs.key;
+				return Compare {}(lhs.key, rhs.key);
 			});
 
 		if (itr == itrEnd)
@@ -212,7 +211,7 @@ class sorted_map
 	vector_type _data;
 };
 
-template <class K>
+template <class K, class Compare = std::less<K>>
 class sorted_set
 {
 public:
@@ -225,8 +224,8 @@ class sorted_set
 	sorted_set(std::initializer_list<K> init)
 		: _data { init }
 	{
-		std::sort(_data.begin(), _data.end(), [](const auto& lhs, const auto& rhs) noexcept {
-			return lhs < rhs;
+		std::sort(_data.begin(), _data.end(), [](const K& lhs, const K& rhs) noexcept {
+			return Compare {}(lhs, rhs);
 		});
 	}
 
@@ -283,8 +282,8 @@ class sorted_set
 	const_iterator find(const K& key) const noexcept
 	{
 		const auto [itr, itrEnd] =
-			std::equal_range(begin(), end(), key, [](const auto& lhs, const auto& rhs) noexcept {
-				return lhs < rhs;
+			std::equal_range(begin(), end(), key, [](const K& lhs, const K& rhs) noexcept {
+				return Compare {}(lhs, rhs);
 			});
 
 		return itr == itrEnd ? _data.end() : itr;
@@ -305,7 +304,7 @@ class sorted_set
 			_data.end(),
 			key,
 			[](const auto& lhs, const auto& rhs) noexcept {
-				return lhs < rhs;
+				return Compare {}(lhs, rhs);
 			});
 
 		if (itr != itrEnd)
@@ -321,8 +320,8 @@ class sorted_set
 		const auto [itr, itrEnd] = std::equal_range(_data.begin(),
 			_data.end(),
 			key,
-			[](const auto& lhs, const auto& rhs) noexcept {
-				return lhs < rhs;
+			[](const K& lhs, const K& rhs) noexcept {
+				return Compare {}(lhs, rhs);
 			});
 
 		if (itr == itrEnd)
@@ -350,6 +349,18 @@ class sorted_set
 	vector_type _data;
 };
 
+struct shorter_or_less
+{
+	constexpr bool operator()(const std::string_view& lhs, const std::string_view& rhs) const
+	{
+		return lhs.size() == rhs.size() ? lhs < rhs : lhs.size() < rhs.size();
+	}
+};
+
+template <class V>
+using string_view_map = sorted_map<std::string_view, V, shorter_or_less>;
+using string_view_set = sorted_set<std::string_view, shorter_or_less>;
+
 } // namespace graphql::internal
 
 #endif // SORTEDMAP_H

samples/separate/AppointmentConnectionObject.cpp

@@ -22,9 +22,9 @@ AppointmentConnection::AppointmentConnection()
 	: service::Object({
 		"AppointmentConnection"
 	}, {
-		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
 		{ R"gql(edges)gql"sv, [this](service::ResolverParams&& params) { return resolveEdges(std::move(params)); } },
-		{ R"gql(pageInfo)gql"sv, [this](service::ResolverParams&& params) { return resolvePageInfo(std::move(params)); } }
+		{ R"gql(pageInfo)gql"sv, [this](service::ResolverParams&& params) { return resolvePageInfo(std::move(params)); } },
+		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } }
 	})
 {
 }

samples/separate/AppointmentEdgeObject.cpp

@@ -22,9 +22,9 @@ AppointmentEdge::AppointmentEdge()
 	: service::Object({
 		"AppointmentEdge"
 	}, {
-		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
+		{ R"gql(node)gql"sv, [this](service::ResolverParams&& params) { return resolveNode(std::move(params)); } },
 		{ R"gql(cursor)gql"sv, [this](service::ResolverParams&& params) { return resolveCursor(std::move(params)); } },
-		{ R"gql(node)gql"sv, [this](service::ResolverParams&& params) { return resolveNode(std::move(params)); } }
+		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } }
 	})
 {
 }

samples/separate/AppointmentObject.cpp

@@ -24,12 +24,12 @@ Appointment::Appointment()
 		"UnionType",
 		"Appointment"
 	}, {
-		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
-		{ R"gql(forceError)gql"sv, [this](service::ResolverParams&& params) { return resolveForceError(std::move(params)); } },
 		{ R"gql(id)gql"sv, [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },
+		{ R"gql(when)gql"sv, [this](service::ResolverParams&& params) { return resolveWhen(std::move(params)); } },
 		{ R"gql(isNow)gql"sv, [this](service::ResolverParams&& params) { return resolveIsNow(std::move(params)); } },
 		{ R"gql(subject)gql"sv, [this](service::ResolverParams&& params) { return resolveSubject(std::move(params)); } },
-		{ R"gql(when)gql"sv, [this](service::ResolverParams&& params) { return resolveWhen(std::move(params)); } }
+		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
+		{ R"gql(forceError)gql"sv, [this](service::ResolverParams&& params) { return resolveForceError(std::move(params)); } }
 	})
 {
 }

samples/separate/CompleteTaskPayloadObject.cpp

@@ -22,9 +22,9 @@ CompleteTaskPayload::CompleteTaskPayload()
 	: service::Object({
 		"CompleteTaskPayload"
 	}, {
+		{ R"gql(task)gql"sv, [this](service::ResolverParams&& params) { return resolveTask(std::move(params)); } },
 		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
-		{ R"gql(clientMutationId)gql"sv, [this](service::ResolverParams&& params) { return resolveClientMutationId(std::move(params)); } },
-		{ R"gql(task)gql"sv, [this](service::ResolverParams&& params) { return resolveTask(std::move(params)); } }
+		{ R"gql(clientMutationId)gql"sv, [this](service::ResolverParams&& params) { return resolveClientMutationId(std::move(params)); } }
 	})
 {
 }

samples/separate/ExpensiveObject.cpp

@@ -22,8 +22,8 @@ Expensive::Expensive()
 	: service::Object({
 		"Expensive"
 	}, {
-		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
-		{ R"gql(order)gql"sv, [this](service::ResolverParams&& params) { return resolveOrder(std::move(params)); } }
+		{ R"gql(order)gql"sv, [this](service::ResolverParams&& params) { return resolveOrder(std::move(params)); } },
+		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } }
 	})
 {
 }

samples/separate/FolderConnectionObject.cpp

@@ -22,9 +22,9 @@ FolderConnection::FolderConnection()
 	: service::Object({
 		"FolderConnection"
 	}, {
-		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
 		{ R"gql(edges)gql"sv, [this](service::ResolverParams&& params) { return resolveEdges(std::move(params)); } },
-		{ R"gql(pageInfo)gql"sv, [this](service::ResolverParams&& params) { return resolvePageInfo(std::move(params)); } }
+		{ R"gql(pageInfo)gql"sv, [this](service::ResolverParams&& params) { return resolvePageInfo(std::move(params)); } },
+		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } }
 	})
 {
 }