Remove <=> operators since AppleClang doesn't support it

Author: wravery

include/graphqlservice/GraphQLResponse.h

@@ -20,7 +20,6 @@
 
 #include "graphqlservice/internal/Awaitable.h"
 
-#include <compare>
 #include <cstdint>
 #include <initializer_list>
 #include <memory>
@@ -91,13 +90,12 @@ struct IdType
 	ValueType release();
 
 	// Comparison
-	GRAPHQLRESPONSE_EXPORT std::strong_ordering operator<=>(const IdType& rhs) const noexcept;
 	GRAPHQLRESPONSE_EXPORT bool operator==(const IdType& rhs) const noexcept;
-	GRAPHQLRESPONSE_EXPORT std::strong_ordering operator<=>(const ByteData& rhs) const noexcept;
 	GRAPHQLRESPONSE_EXPORT bool operator==(const ByteData& rhs) const noexcept;
-	GRAPHQLRESPONSE_EXPORT std::strong_ordering operator<=>(const OpaqueString& rhs) const noexcept;
 	GRAPHQLRESPONSE_EXPORT bool operator==(const OpaqueString& rhs) const noexcept;
 
+	GRAPHQLRESPONSE_EXPORT bool operator<(const IdType& rhs) const noexcept;
+
 	// Check the Type
 	GRAPHQLRESPONSE_EXPORT bool isBase64() const noexcept;
 
@@ -190,7 +188,6 @@ struct Value
 	Value& operator=(const Value& rhs) = delete;
 
 	// Comparison
-	GRAPHQLRESPONSE_EXPORT std::partial_ordering operator<=>(const Value& rhs) const noexcept;
 	GRAPHQLRESPONSE_EXPORT bool operator==(const Value& rhs) const noexcept;
 
 	// Check the Type
@@ -243,24 +240,16 @@ struct Value
 	// Type::Map
 	struct MapData
 	{
-		std::partial_ordering operator<=>(const MapData& rhs) const;
+		bool operator==(const MapData& rhs) const;
 
 		MapType map;
 		std::vector<size_t> members;
 	};
 
-	// Type::List
-	struct ListData
-	{
-		std::partial_ordering operator<=>(const ListData& rhs) const;
-
-		std::vector<Value> entries;
-	};
-
 	// Type::String
 	struct StringData
 	{
-		std::strong_ordering operator<=>(const StringData& rhs) const;
+		bool operator==(const StringData& rhs) const;
 
 		StringType string;
 		bool from_json = false;
@@ -270,7 +259,7 @@ struct Value
 	// Type::Null
 	struct NullData
 	{
-		std::strong_ordering operator<=>(const NullData& rhs) const;
+		bool operator==(const NullData& rhs) const;
 	};
 
 	// Type::EnumValue
@@ -279,14 +268,14 @@ struct Value
 	// Type::Scalar
 	struct ScalarData
 	{
-		std::partial_ordering operator<=>(const ScalarData& rhs) const;
+		bool operator==(const ScalarData& rhs) const;
 
 		std::unique_ptr<ScalarType> scalar;
 	};
 
 	using SharedData = std::shared_ptr<const Value>;
 
-	using TypeData = std::variant<MapData, ListData, StringData, NullData, BooleanType, IntType,
+	using TypeData = std::variant<MapData, ListType, StringData, NullData, BooleanType, IntType,
 		FloatType, EnumData, IdType, ScalarData, SharedData>;
 
 	const TypeData& data() const noexcept;

include/graphqlservice/internal/Base64.h

@@ -19,6 +19,7 @@
 // clang-format on
 
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -56,11 +57,20 @@ class Base64
 	// Convert a set of bytes to Base64.
 	GRAPHQLRESPONSE_EXPORT static std::string toBase64(const std::vector<std::uint8_t>& bytes);
 
-	// Compare a set of bytes to possible Base64.
-	GRAPHQLRESPONSE_EXPORT static bool compareBase64(
+	enum class Comparison
+	{
+		LessThan = -1,
+		EqualTo = 0,
+		GreaterThan = 1,
+
+		InvalidBase64 = 2,
+	};
+
+	// Compare a set of bytes to a possible Base64 string without performing any heap allocations.
+	GRAPHQLRESPONSE_EXPORT static Comparison compareBase64(
 		const std::vector<std::uint8_t>& bytes, std::string_view maybeEncoded) noexcept;
 
-	// Validate a whether or not a string is valid Base64.
+	// Validate a whether or not a string is valid Base64 without performing any heap allocations.
 	GRAPHQLRESPONSE_EXPORT static bool validateBase64(std::string_view maybeEncoded) noexcept;
 
 private:

src/Base64.cpp

@@ -149,14 +149,22 @@ std::string Base64::toBase64(const std::vector<std::uint8_t>& bytes)
 	return result;
 }
 
-bool Base64::compareBase64(
+Base64::Comparison Base64::compareBase64(
 	const std::vector<std::uint8_t>& bytes, std::string_view maybeEncoded) noexcept
 {
-	if (bytes.empty() || maybeEncoded.empty())
+	if (bytes.empty())
 	{
-		return bytes.empty() && maybeEncoded.empty();
+		if (maybeEncoded.empty())
+		{
+			return Comparison::EqualTo;
+		}
+	}
+	else if (maybeEncoded.empty())
+	{
+		return Comparison::GreaterThan;
 	}
 
+	auto result = Comparison::EqualTo;
 	auto itr = bytes.cbegin();
 	const auto itrEnd = bytes.cend();
 
@@ -171,18 +179,34 @@ bool Base64::compareBase64(
 		if (((a | b | c | d) & 0xC0) != 0)
 		{
 			// Invalid Base64 characters
-			return false;
+			return Comparison::InvalidBase64;
 		}
 
-		const uint32_t segment = (static_cast<uint32_t>(a) << 18) | (static_cast<uint32_t>(b) << 12)
-			| (static_cast<uint32_t>(c) << 6) | static_cast<uint32_t>(d);
-
-		if (itr == itrEnd || *itr++ != static_cast<std::uint8_t>((segment & 0xFF0000) >> 16)
-			|| itr == itrEnd || *itr++ != static_cast<std::uint8_t>((segment & 0xFF00) >> 8)
-			|| itr == itrEnd || *itr++ != static_cast<std::uint8_t>(segment & 0xFF))
+		if (Comparison::EqualTo == result)
 		{
-			// Decoded bytes did not match
-			return false;
+			const uint32_t segment = (static_cast<uint32_t>(a) << 18)
+				| (static_cast<uint32_t>(b) << 12) | (static_cast<uint32_t>(c) << 6)
+				| static_cast<uint32_t>(d);
+			const std::array decoded { static_cast<std::uint8_t>((segment & 0xFF0000) >> 16),
+				static_cast<std::uint8_t>((segment & 0xFF00) >> 8),
+				static_cast<std::uint8_t>(segment & 0xFF) };
+
+			for (auto value : decoded)
+			{
+				if (itr == itrEnd)
+				{
+					result = Comparison::LessThan;
+					break;
+				}
+
+				if (*itr != value)
+				{
+					result = *itr < value ? Comparison::LessThan : Comparison::GreaterThan;
+					break;
+				}
+
+				++itr;
+			}
 		}
 
 		maybeEncoded = maybeEncoded.substr(4);
@@ -199,55 +223,81 @@ bool Base64::compareBase64(
 		if (((a | b | c) & 0xC0) != 0 || (c & 0x3) != 0)
 		{
 			// Invalid Base64 characters or padding
-			return false;
+			return Comparison::InvalidBase64;
 		}
 
 		const uint16_t segment = (static_cast<uint16_t>(a) << 10) | (static_cast<uint16_t>(b) << 4)
 			| (static_cast<uint16_t>(c) >> 2);
+		const std::array decoded { static_cast<std::uint8_t>((segment & 0xFF00) >> 8),
+			static_cast<std::uint8_t>(segment & 0xFF) };
 
 		if (triplet)
 		{
-			if (itr == itrEnd || *itr++ != static_cast<std::uint8_t>((segment & 0xFF00) >> 8)
-				|| itr == itrEnd || *itr++ != static_cast<std::uint8_t>(segment & 0xFF))
+			if (Comparison::EqualTo == result)
 			{
-				// Decoded bytes did not match
-				return false;
+				for (auto value : decoded)
+				{
+					if (itr == itrEnd)
+					{
+						result = Comparison::LessThan;
+						break;
+					}
+
+					if (*itr != value)
+					{
+						result = *itr < value ? Comparison::LessThan : Comparison::GreaterThan;
+						break;
+					}
+
+					++itr;
+				}
 			}
 
 			maybeEncoded = maybeEncoded.substr(3);
 		}
 		else
 		{
-			if ((segment & 0xFF) != 0)
+			if (decoded[1] != 0)
 			{
 				// Invalid padding
-				return false;
+				return Comparison::InvalidBase64;
 			}
 
-			if (itr == itrEnd || *itr++ != static_cast<std::uint8_t>((segment & 0xFF00) >> 8))
+			if (Comparison::EqualTo == result)
 			{
-				// Decoded byte did not match
-				return false;
+				if (itr == itrEnd)
+				{
+					result = Comparison::LessThan;
+				}
+				else if (*itr != decoded[0])
+				{
+					result = *itr < decoded[0] ? Comparison::LessThan : Comparison::GreaterThan;
+				}
+
+				++itr;
 			}
 
 			maybeEncoded = maybeEncoded.substr(2);
 		}
 	}
 
-	// We should reach the end of the byte vector
-	if (itr != itrEnd)
-	{
-		return false;
-	}
-
 	// Make sure anything that's left is 0 - 2 characters of padding
 	if ((maybeEncoded.size() > 0 && padding != maybeEncoded[0])
 		|| (maybeEncoded.size() > 1 && padding != maybeEncoded[1]) || maybeEncoded.size() > 2)
 	{
-		return false;
+		return Comparison::InvalidBase64;
 	}
 
-	return true;
+	if (Comparison::EqualTo == result)
+	{
+		// We should reach the end of the byte vector
+		if (itr != itrEnd)
+		{
+			result = Comparison::GreaterThan;
+		}
+	}
+
+	return result;
 }
 
 bool Base64::validateBase64(std::string_view maybeEncoded) noexcept