Fixed url encode/decode functions

awwit · awwit · commit ba4c4d15b302 · 2016-01-31T00:58:23.000+03:00
diff --git a/src/Utils.cpp b/src/Utils.cpp
@@ -21,16 +21,16 @@ namespace Utils
 
 	void trim(std::string &str)
 	{
-		static const char whitespace[] = {" \t\n\v\f\r"};
+		static const std::array<char, 7> whitespace { " \t\n\v\f\r" };
 
-		const size_t last = str.find_last_not_of(whitespace);
+		const size_t last = str.find_last_not_of(whitespace.data() );
 
 		if (std::string::npos == last)
 		{
 			return str.clear();
 		}
 
-		str.assign(str.cbegin() + str.find_first_not_of(whitespace), str.cbegin() + last + 1);
+		str.assign(str.cbegin() + str.find_first_not_of(whitespace.data() ), str.cbegin() + last + 1);
 	}
 
 	std::vector<std::string> explode(const std::string &str, const char sep)
@@ -84,12 +84,12 @@ namespace Utils
 
 		const uint8_t *bin = reinterpret_cast<const uint8_t *>(binData);
 
-		const char hexDigits[] = { "0123456789abcdef" };
+		static const std::array<char, 17> hexDigits { "0123456789abcdef" };
 
 		for (size_t i = dataSize - 1; std::numeric_limits<size_t>::max() != i; --i)
 		{
-			str[(i << 1) + 0] = hexDigits[bin[i] >> 4];
-			str[(i << 1) + 1] = hexDigits[bin[i] & 0x0F];
+			str[i * 2 + 0] = hexDigits[bin[i] >> 4];
+			str[i * 2 + 1] = hexDigits[bin[i] & 0x0F];
 		}
 
 		return str;
@@ -119,8 +119,8 @@ namespace Utils
 
 		for (size_t i = 0; i < bin.length(); ++i)
 		{
-			const char a = hexStr[(i << 1) + 0];
-			const char b = hexStr[(i << 1) + 1];
+			const char a = hexStr[i * 2 + 0];
+			const char b = hexStr[i * 2 + 1];
 
 			bin[i] = (
 				(hexStringToBinEncodeSymbol(a) << 4) | hexStringToBinEncodeSymbol(b)
@@ -387,81 +387,71 @@ namespace Utils
 		return true;
 	}
 
-	inline bool isUrlAllowed(const char c)
+	static inline bool isCharUrlAllowed(const char c)
 	{
-		static const std::string special("-_.~");
-
-		return std::string::npos != special.find(c);
+		return c == '-' || c == '_' || c == '.' || c == '~';
 	}
 
 	std::string urlEncode(const std::string &str)
 	{
-		std::ostringstream encoded;
-		encoded.fill('0');
-		encoded << std::hex;
+		std::string encoded;
+
+		static const std::array<char, 17> hexDigits { "0123456789abcdef" };
 
-		for (auto it = str.cbegin(); str.cend() != it; ++it)
+		for (size_t i = 0; i < str.length(); ++i)
 		{
-			const char &c = *it;
+			const unsigned char c = str[i];
 
-			if (' ' == c)
+			if (std::isalnum(c) || isCharUrlAllowed(c) )
 			{
-				encoded << '+';
+				encoded.push_back(c);
 			}
-			else if (std::isalnum(c) || isUrlAllowed(c) )
+			else if (' ' == c)
 			{
-				encoded << c;
+				encoded.push_back('+');
 			}
 			else
 			{
-				encoded << '%' << std::setw(2) << (int) ( (unsigned char) c);
+				const uint8_t a = c >> 4;
+				const uint8_t b = c & 0x0F;
+
+				encoded.push_back('%');
+				encoded.push_back(hexDigits[a]);
+				encoded.push_back(hexDigits[b]);
 			}
 		}
 
-		return encoded.str();
+		return encoded;
 	}
 
 	std::string urlDecode(const std::string &str)
 	{
 		std::string decoded;
 
-		// ch length must be >= 3
-		std::array<char, sizeof(size_t)> ch;
-
-		for (auto it = str.cbegin(); str.cend() != it; ++it)
+		for (size_t i = 0; i < str.length(); ++i)
 		{
-			const char &c = *it;
+			unsigned char c = str[i];
 
 			if ('%' == c)
 			{
-				++it;
-
-				if (str.cend() == it)
+				if (i + 2 < str.length() )
 				{
-					break;
-				}
-
-				ch[0] = *it;
+					const char a = str[i + 1];
+					const char b = str[i + 2];
 
-				++it;
+					c = (
+						(hexStringToBinEncodeSymbol(a) << 4) | hexStringToBinEncodeSymbol(b)
+					);
 
-				if (str.cend() == it)
-				{
-					break;
+					i += 2;
 				}
-
-				ch[1] = *it;
-
-				decoded.push_back(strtoul(ch.data(), nullptr, 16) );
 			}
 			else if ('+' == c)
 			{
-				decoded.push_back(' ');
-			}
-			else
-			{
-				decoded.push_back(c);
+				c = ' ';
 			}
+
+			decoded.push_back(c);
 		}
 
 		return decoded;

Original file line number	Diff line number	Diff line change
`@@ -21,16 +21,16 @@ namespace Utils`
`21`	`21`
`22`	`22`	`void trim(std::string &str)`
`23`	`23`	`{`
`24`		`- static const char whitespace[] = {" \t\n\v\f\r"};`
	`24`	`+ static const std::array<char, 7> whitespace { " \t\n\v\f\r" };`
`25`	`25`
`26`		`- const size_t last = str.find_last_not_of(whitespace);`
	`26`	`+ const size_t last = str.find_last_not_of(whitespace.data() );`
`27`	`27`
`28`	`28`	`if (std::string::npos == last)`
`29`	`29`	`{`
`30`	`30`	`return str.clear();`
`31`	`31`	`}`
`32`	`32`
`33`		`- str.assign(str.cbegin() + str.find_first_not_of(whitespace), str.cbegin() + last + 1);`
	`33`	`+ str.assign(str.cbegin() + str.find_first_not_of(whitespace.data() ), str.cbegin() + last + 1);`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`std::vector<std::string> explode(const std::string &str, const char sep)`
`@@ -84,12 +84,12 @@ namespace Utils`
`84`	`84`
`85`	`85`	`const uint8_t bin = reinterpret_cast<const uint8_t >(binData);`
`86`	`86`
`87`		`- const char hexDigits[] = { "0123456789abcdef" };`
	`87`	`+ static const std::array<char, 17> hexDigits { "0123456789abcdef" };`
`88`	`88`
`89`	`89`	`for (size_t i = dataSize - 1; std::numeric_limits<size_t>::max() != i; --i)`
`90`	`90`	`{`
`91`		`- str[(i << 1) + 0] = hexDigits[bin[i] >> 4];`
`92`		`- str[(i << 1) + 1] = hexDigits[bin[i] & 0x0F];`
	`91`	`+ str[i * 2 + 0] = hexDigits[bin[i] >> 4];`
	`92`	`+ str[i * 2 + 1] = hexDigits[bin[i] & 0x0F];`
`93`	`93`	`}`
`94`	`94`
`95`	`95`	`return str;`
`@@ -119,8 +119,8 @@ namespace Utils`
`119`	`119`
`120`	`120`	`for (size_t i = 0; i < bin.length(); ++i)`
`121`	`121`	`{`
`122`		`- const char a = hexStr[(i << 1) + 0];`
`123`		`- const char b = hexStr[(i << 1) + 1];`
	`122`	`+ const char a = hexStr[i * 2 + 0];`
	`123`	`+ const char b = hexStr[i * 2 + 1];`
`124`	`124`
`125`	`125`	`bin[i] = (`
`126`	`126`	`(hexStringToBinEncodeSymbol(a) << 4) \| hexStringToBinEncodeSymbol(b)`
`@@ -387,81 +387,71 @@ namespace Utils`
`387`	`387`	`return true;`
`388`	`388`	`}`
`389`	`389`
`390`		`- inline bool isUrlAllowed(const char c)`
	`390`	`+ static inline bool isCharUrlAllowed(const char c)`
`391`	`391`	`{`
`392`		`- static const std::string special("-_.~");`
`393`		`-`
`394`		`- return std::string::npos != special.find(c);`
	`392`	`+ return c == '-' \|\| c == '_' \|\| c == '.' \|\| c == '~';`
`395`	`393`	`}`
`396`	`394`
`397`	`395`	`std::string urlEncode(const std::string &str)`
`398`	`396`	`{`
`399`		`- std::ostringstream encoded;`
`400`		`- encoded.fill('0');`
`401`		`- encoded << std::hex;`
	`397`	`+ std::string encoded;`
	`398`	`+`
	`399`	`+ static const std::array<char, 17> hexDigits { "0123456789abcdef" };`
`402`	`400`
`403`		`- for (auto it = str.cbegin(); str.cend() != it; ++it)`
	`401`	`+ for (size_t i = 0; i < str.length(); ++i)`
`404`	`402`	`{`
`405`		`- const char &c = *it;`
	`403`	`+ const unsigned char c = str[i];`
`406`	`404`
`407`		`- if (' ' == c)`
	`405`	`+ if (std::isalnum(c) \|\| isCharUrlAllowed(c) )`
`408`	`406`	`{`
`409`		`- encoded << '+';`
	`407`	`+ encoded.push_back(c);`
`410`	`408`	`}`
`411`		`- else if (std::isalnum(c) \|\| isUrlAllowed(c) )`
	`409`	`+ else if (' ' == c)`
`412`	`410`	`{`
`413`		`- encoded << c;`
	`411`	`+ encoded.push_back('+');`
`414`	`412`	`}`
`415`	`413`	`else`
`416`	`414`	`{`
`417`		`- encoded << '%' << std::setw(2) << (int) ( (unsigned char) c);`
	`415`	`+ const uint8_t a = c >> 4;`
	`416`	`+ const uint8_t b = c & 0x0F;`
	`417`	`+`
	`418`	`+ encoded.push_back('%');`
	`419`	`+ encoded.push_back(hexDigits[a]);`
	`420`	`+ encoded.push_back(hexDigits[b]);`
`418`	`421`	`}`
`419`	`422`	`}`
`420`	`423`
`421`		`- return encoded.str();`
	`424`	`+ return encoded;`
`422`	`425`	`}`
`423`	`426`
`424`	`427`	`std::string urlDecode(const std::string &str)`
`425`	`428`	`{`
`426`	`429`	`std::string decoded;`
`427`	`430`
`428`		`- // ch length must be >= 3`
`429`		`- std::array<char, sizeof(size_t)> ch;`
`430`		`-`
`431`		`- for (auto it = str.cbegin(); str.cend() != it; ++it)`
	`431`	`+ for (size_t i = 0; i < str.length(); ++i)`
`432`	`432`	`{`
`433`		`- const char &c = *it;`
	`433`	`+ unsigned char c = str[i];`
`434`	`434`
`435`	`435`	`if ('%' == c)`
`436`	`436`	`{`
`437`		`- ++it;`
`438`		`-`
`439`		`- if (str.cend() == it)`
	`437`	`+ if (i + 2 < str.length() )`
`440`	`438`	`{`
`441`		`- break;`
`442`		`- }`
`443`		`-`
`444`		`- ch[0] = *it;`
	`439`	`+ const char a = str[i + 1];`
	`440`	`+ const char b = str[i + 2];`
`445`	`441`
`446`		`- ++it;`
	`442`	`+ c = (`
	`443`	`+ (hexStringToBinEncodeSymbol(a) << 4) \| hexStringToBinEncodeSymbol(b)`
	`444`	`+ );`
`447`	`445`
`448`		`- if (str.cend() == it)`
`449`		`- {`
`450`		`- break;`
	`446`	`+ i += 2;`
`451`	`447`	`}`
`452`		`-`
`453`		`- ch[1] = *it;`
`454`		`-`
`455`		`- decoded.push_back(strtoul(ch.data(), nullptr, 16) );`
`456`	`448`	`}`
`457`	`449`	`else if ('+' == c)`
`458`	`450`	`{`
`459`		`- decoded.push_back(' ');`
`460`		`- }`
`461`		`- else`
`462`		`- {`
`463`		`- decoded.push_back(c);`
	`451`	`+ c = ' ';`
`464`	`452`	`}`
	`453`	`+`
	`454`	`+ decoded.push_back(c);`
`465`	`455`	`}`
`466`	`456`
`467`	`457`	`return decoded;`