Cleanup inconsistent ID type handling and vectorize Base64

Author: wravery

GraphQLService.cpp

@@ -8,6 +8,7 @@
 #include <iostream>
 #include <algorithm>
 #include <stdexcept>
+#include <array>
 
 namespace facebook {
 namespace graphql {
@@ -48,7 +49,7 @@ const peg::ast_node& Fragment::getSelection() const
 	return _selection;
 }
 
-uint8_t Base64::verifyFromBase64(unsigned char ch)
+uint8_t Base64::verifyFromBase64(char ch)
 {
 	uint8_t result = fromBase64(ch);
 
@@ -60,70 +61,94 @@ uint8_t Base64::verifyFromBase64(unsigned char ch)
 	return result;
 }
 
-std::vector<unsigned char> Base64::fromBase64(const char* encoded, size_t count)
+std::vector<uint8_t> Base64::fromBase64(const char* encoded, size_t count)
 {
-	std::vector<unsigned char> result;
+	std::vector<uint8_t> result;
 
 	if (!count)
 	{
 		return result;
 	}
 
-	result.reserve(count * 3 / 4);
-	while (encoded[0] && encoded[1])
+	result.reserve((count + (count % 4)) * 3 / 4);
+
+	// First decode all of the full unpadded segments 24 bits at a time
+	while (count >= 4
+		&& encoded[3] != padding)
 	{
-		uint16_t buffer = static_cast<uint16_t>(verifyFromBase64(*encoded++)) << 10;
+		const uint32_t segment = (static_cast<uint32_t>(verifyFromBase64(encoded[0])) << 18)
+			| (static_cast<uint32_t>(verifyFromBase64(encoded[1])) << 12)
+			| (static_cast<uint32_t>(verifyFromBase64(encoded[2])) << 6)
+			| static_cast<uint32_t>(verifyFromBase64(encoded[3]));
+
+		result.emplace_back(static_cast<uint8_t>((segment & 0xFF0000) >> 16));
+		result.emplace_back(static_cast<uint8_t>((segment & 0xFF00) >> 8));
+		result.emplace_back(static_cast<uint8_t>(segment & 0xFF));
+
+		encoded += 4;
+		count -= 4;
+	}
 
-		buffer |= static_cast<uint16_t>(verifyFromBase64(*encoded++)) << 4;
-		result.push_back(static_cast<unsigned char>((buffer & 0xFF00) >> 8));
-		buffer = (buffer & 0xFF) << 8;
+	// Get any leftover partial segment with 2 or 3 non-padding characters
+	if (count > 1)
+	{
+		const bool triplet = (count > 2 && padding != encoded[2]);
+		const uint8_t tail = (triplet ? verifyFromBase64(encoded[2]) : 0);
+		const uint16_t segment = (static_cast<uint16_t>(verifyFromBase64(encoded[0])) << 10)
+			| (static_cast<uint16_t>(verifyFromBase64(encoded[1])) << 4)
+			| (static_cast<uint16_t>(tail) >> 2);
 
-		if (!*encoded || '=' == *encoded)
+		if (triplet)
 		{
-			if (0 != buffer
-				|| (*encoded && (*++encoded != '=' || *++encoded)))
+			if (tail & 0x3)
 			{
 				throw schema_exception({ "invalid padding at the end of a base64 encoded string" });
 			}
 
-			break;
-		}
-
-		buffer |= static_cast<uint16_t>(verifyFromBase64(*encoded++)) << 6;
-		result.push_back(static_cast<unsigned char>((buffer & 0xFF00) >> 8));
-		buffer &= 0xFF;
+			result.emplace_back(static_cast<uint8_t>((segment & 0xFF00) >> 8));
+			result.emplace_back(static_cast<uint8_t>(segment & 0xFF));
 
-		if (!*encoded || '=' == *encoded)
+			encoded += 3;
+			count -= 3;
+		}
+		else
 		{
-			if (0 != buffer
-				|| (*encoded && *++encoded))
+			if (segment & 0xFF)
 			{
 				throw schema_exception({ "invalid padding at the end of a base64 encoded string" });
 			}
 
-			break;
+			result.emplace_back(static_cast<uint8_t>((segment & 0xFF00) >> 8));
+
+			encoded += 2;
+			count -= 2;
 		}
+	}
 
-		buffer |= static_cast<uint16_t>(verifyFromBase64(*encoded++));
-		result.push_back(static_cast<unsigned char>(buffer & 0xFF));
+	// Make sure anything that's left is 0 - 2 characters of padding
+	if ((count > 0 && padding != encoded[0])
+		|| (count > 1 && padding != encoded[1])
+		|| count > 2)
+	{
+		throw schema_exception({ "invalid padding at the end of a base64 encoded string" });
 	}
 
 	return result;
 }
 
-unsigned char Base64::verifyToBase64(uint8_t i)
+char Base64::verifyToBase64(uint8_t i)
 {
 	unsigned char result = toBase64(i);
 
-	if (result == '=')
+	if (result == padding)
 	{
 		throw std::logic_error("invalid 6-bit value");
 	}
 
 	return result;
 }
 
-std::string Base64::toBase64(const std::vector<unsigned char>& bytes)
+std::string Base64::toBase64(const std::vector<uint8_t>& bytes)
 {
 	std::string result;
 
@@ -132,38 +157,43 @@ std::string Base64::toBase64(const std::vector<unsigned char>& bytes)
 		return result;
 	}
 
-	auto itr = bytes.cbegin();
-	const auto itrEnd = bytes.cend();
-	const size_t count = bytes.size();
+	size_t count = bytes.size();
+	const uint8_t* data = bytes.data();
 
 	result.reserve((count + (count % 3)) * 4 / 3);
-	while (itr != itrEnd)
-	{
-		uint16_t buffer = static_cast<uint8_t>(*itr++) << 8;
-
-		result.push_back(verifyToBase64((buffer & 0xFC00) >> 10));
-
-		if (itr == itrEnd)
-		{
-			result.push_back(verifyToBase64((buffer & 0x03F0) >> 4));
-			result.append("==");
-			break;
-		}
 
-		buffer |= static_cast<uint8_t>(*itr++);
-		result.push_back(verifyToBase64((buffer & 0x03F0) >> 4));
-		buffer = buffer << 8;
+	// First encode all of the full unpadded segments 24 bits at a time
+	while (count >= 3)
+	{
+		const uint32_t segment = (static_cast<uint32_t>(data[0]) << 16)
+			| (static_cast<uint32_t>(data[1]) << 8)
+			| static_cast<uint32_t>(data[2]);
+
+		result.append({
+			verifyToBase64((segment & 0xFC0000) >> 18),
+			verifyToBase64((segment & 0x3F000) >> 12),
+			verifyToBase64((segment & 0xFC0) >> 6),
+			verifyToBase64(segment & 0x3F)
+			});
 
-		if (itr == itrEnd)
-		{
-			result.push_back(verifyToBase64((buffer & 0x0FC0) >> 6));
-			result.push_back('=');
-			break;
-		}
+		data += 3;
+		count -= 3;
+	}
 
-		buffer |= static_cast<uint8_t>(*itr++);
-		result.push_back(verifyToBase64((buffer & 0x0FC0) >> 6));
-		result.push_back(verifyToBase64(buffer & 0x3F));
+	// Get any leftover partial segment with 1 or 2 bytes
+	if (count > 0)
+	{
+		const bool pair = (count > 1);
+		const uint16_t segment = (static_cast<uint16_t>(data[0]) << 8)
+			| (pair ? static_cast<uint16_t>(data[1]) : 0);
+		const std::array<char, 4> remainder {
+			verifyToBase64((segment & 0xFC00) >> 10),
+			verifyToBase64((segment & 0x3F0) >> 4),
+			(pair ? verifyToBase64((segment & 0xF) << 2) : padding),
+			padding
+		};
+
+		result.append(remainder.data(), remainder.size());
 	}
 
 	return result;
@@ -229,7 +259,7 @@ rapidjson::Document ModifiedArgument<rapidjson::Document>::convert(const rapidjs
 }
 
 template <>
-std::vector<unsigned char> ModifiedArgument<std::vector<unsigned char>>::convert(const rapidjson::Value& value)
+std::vector<uint8_t> ModifiedArgument<std::vector<uint8_t>>::convert(const rapidjson::Value& value)
 {
 	if (!value.IsString())
 	{
@@ -282,7 +312,7 @@ rapidjson::Document ModifiedResult<rapidjson::Document>::convert(rapidjson::Docu
 }
 
 template <>
-rapidjson::Document ModifiedResult<std::vector<unsigned char>>::convert(std::vector<unsigned char>&& result, ResolverParams&&)
+rapidjson::Document ModifiedResult<std::vector<uint8_t>>::convert(std::vector<uint8_t>&& result, ResolverParams&&)
 {
 	rapidjson::Document document(rapidjson::Type::kStringType);
 

GraphQLService.h

@@ -76,7 +76,7 @@ class Base64
 {
 public:
 	// Map a single Base64-encoded character to its 6-bit integer value.
-	static constexpr uint8_t fromBase64(unsigned char ch) noexcept
+	static constexpr uint8_t fromBase64(char ch) noexcept
 	{
 		return (ch >= 'A' && ch <= 'Z' ? ch - 'A'
 			: (ch >= 'a' && ch <= 'z' ? ch - 'a' + 26
@@ -86,27 +86,29 @@ class Base64
 	}
 
 	// Convert a Base64-encoded string to a vector of bytes.
-	static std::vector<unsigned char> fromBase64(const char* encoded, size_t count);
+	static std::vector<uint8_t> fromBase64(const char* encoded, size_t count);
 
 	// Map a single 6-bit integer value to its Base64-encoded character.
-	static constexpr unsigned char toBase64(uint8_t i) noexcept
+	static constexpr char toBase64(uint8_t i) noexcept
 	{
-		return (i < 26 ? i + static_cast<uint8_t>('A')
-			: (i < 52 ? i - 26 + static_cast<uint8_t>('a')
-				: (i < 62 ? i - 52 + static_cast<uint8_t>('0')
+		return (i < 26 ? static_cast<char>(i + static_cast<uint8_t>('A'))
+			: (i < 52 ? static_cast<char>(i - 26 + static_cast<uint8_t>('a'))
+				: (i < 62 ? static_cast<char>(i - 52 + static_cast<uint8_t>('0'))
 					: (i == 62 ? '+'
-						: (i == 63 ? '/' : '=')))));
+						: (i == 63 ? '/' : padding)))));
 	}
 
 	// Convert a set of bytes to Base64.
-	static std::string toBase64(const std::vector<unsigned char>& bytes);
+	static std::string toBase64(const std::vector<uint8_t>& bytes);
 
 private:
+	static constexpr char padding = '=';
+
 	// Throw a schema_exception if the character is out of range.
-	static uint8_t verifyFromBase64(unsigned char ch);
+	static uint8_t verifyFromBase64(char ch);
 
 	// Throw a logic_error if the integer is out of range.
-	static unsigned char verifyToBase64(uint8_t i);
+	static char verifyToBase64(uint8_t i);
 };
 
 // Types be wrapped non-null or list types in GraphQL. Since nullability is a more special case
@@ -250,7 +252,7 @@ using IntArgument = ModifiedArgument<int>;
 using FloatArgument = ModifiedArgument<double>;
 using StringArgument = ModifiedArgument<std::string>;
 using BooleanArgument = ModifiedArgument<bool>;
-using IdArgument = ModifiedArgument<std::vector<unsigned char>>;
+using IdArgument = ModifiedArgument<std::vector<uint8_t>>;
 using ScalarArgument = ModifiedArgument<rapidjson::Document>;
 
 // Each type should handle fragments with type conditions matching its own

SchemaGenerator.cpp

@@ -33,7 +33,7 @@ const CppTypeMap Generator::s_builtinCppTypes= {
 		"double",
 		"std::string",
 		"bool",
-		"std::vector<unsigned char>",
+		"std::vector<uint8_t>",
 	};
 
 const std::string Generator::s_scalarCppType = R"cpp(rapidjson::Document)cpp";

Today.cpp

@@ -10,22 +10,22 @@ namespace facebook {
 namespace graphql {
 namespace today {
 
-Appointment::Appointment(std::vector<unsigned char>&& id, std::string&& when, std::string&& subject, bool isNow)
+Appointment::Appointment(std::vector<uint8_t>&& id, std::string&& when, std::string&& subject, bool isNow)
 	: _id(std::move(id))
 	, _when(std::move(when))
 	, _subject(std::move(subject))
 	, _isNow(isNow)
 {
 }
 
-Task::Task(std::vector<unsigned char>&& id, std::string&& title, bool isComplete)
+Task::Task(std::vector<uint8_t>&& id, std::string&& title, bool isComplete)
 	: _id(std::move(id))
 	, _title(std::move(title))
 	, _isComplete(isComplete)
 {
 }
 
-Folder::Folder(std::vector<unsigned char>&& id, std::string&& name, int unreadCount)
+Folder::Folder(std::vector<uint8_t>&& id, std::string&& name, int unreadCount)
 	: _id(std::move(id))
 	, _name(std::move(name))
 	, _unreadCount(unreadCount)
@@ -48,7 +48,7 @@ void Query::loadAppointments() const
 	}
 }
 
-std::shared_ptr<Appointment> Query::findAppointment(const std::vector<unsigned char>& id) const
+std::shared_ptr<Appointment> Query::findAppointment(const std::vector<uint8_t>& id) const
 {
 	loadAppointments();
 
@@ -74,7 +74,7 @@ void Query::loadTasks() const
 	}
 }
 
-std::shared_ptr<Task> Query::findTask(const std::vector<unsigned char>& id) const
+std::shared_ptr<Task> Query::findTask(const std::vector<uint8_t>& id) const
 {
 	loadTasks();
 
@@ -100,7 +100,7 @@ void Query::loadUnreadCounts() const
 	}
 }
 
-std::shared_ptr<Folder> Query::findUnreadCount(const std::vector<unsigned char>& id) const
+std::shared_ptr<Folder> Query::findUnreadCount(const std::vector<uint8_t>& id) const
 {
 	loadUnreadCounts();
 
@@ -117,7 +117,7 @@ std::shared_ptr<Folder> Query::findUnreadCount(const std::vector<unsigned char>&
 	return nullptr;
 }
 
-std::shared_ptr<service::Object> Query::getNode(std::vector<unsigned char>&& id) const
+std::shared_ptr<service::Object> Query::getNode(std::vector<uint8_t>&& id) const
 {
 	auto appointment = findAppointment(id);
 
@@ -263,38 +263,38 @@ std::shared_ptr<object::FolderConnection> Query::getUnreadCounts(std::unique_ptr
 	return std::static_pointer_cast<object::FolderConnection>(connection);
 }
 
-std::vector<std::shared_ptr<object::Appointment>> Query::getAppointmentsById(std::vector<std::vector<unsigned char>>&& ids) const
+std::vector<std::shared_ptr<object::Appointment>> Query::getAppointmentsById(std::vector<std::vector<uint8_t>>&& ids) const
 {
 	std::vector<std::shared_ptr<object::Appointment>> result(ids.size());
 
 	std::transform(ids.cbegin(), ids.cend(), result.begin(),
-		[this](const std::vector<unsigned char>& id)
+		[this](const std::vector<uint8_t>& id)
 	{
 		return std::static_pointer_cast<object::Appointment>(findAppointment(id));
 	});
 
 	return result;
 }
 
-std::vector<std::shared_ptr<object::Task>> Query::getTasksById(std::vector<std::vector<unsigned char>>&& ids) const
+std::vector<std::shared_ptr<object::Task>> Query::getTasksById(std::vector<std::vector<uint8_t>>&& ids) const
 {
 	std::vector<std::shared_ptr<object::Task>> result(ids.size());
 
 	std::transform(ids.cbegin(), ids.cend(), result.begin(),
-		[this](const std::vector<unsigned char>& id)
+		[this](const std::vector<uint8_t>& id)
 	{
 		return std::static_pointer_cast<object::Task>(findTask(id));
 	});
 
 	return result;
 }
 
-std::vector<std::shared_ptr<object::Folder>> Query::getUnreadCountsById(std::vector<std::vector<unsigned char>>&& ids) const
+std::vector<std::shared_ptr<object::Folder>> Query::getUnreadCountsById(std::vector<std::vector<uint8_t>>&& ids) const
 {
 	std::vector<std::shared_ptr<object::Folder>> result(ids.size());
 
 	std::transform(ids.cbegin(), ids.cend(), result.begin(),
-		[this](const std::vector<unsigned char>& id)
+		[this](const std::vector<uint8_t>& id)
 	{
 		return std::static_pointer_cast<object::Folder>(findUnreadCount(id));
 	});