Fixed issues with Unicode

uglide · uglide · commit e783d7d6ae5e · 2013-12-26T20:34:33.000+02:00
diff --git a/redis-desktop-manager/include/redis/Response.h b/redis-desktop-manager/include/redis/Response.h
@@ -10,14 +10,14 @@ class Response
 
 public:
     Response();
-    Response(QString &);
+    Response(const QByteArray &);
     ~Response(void);
 
     QVariant getValue();
     bool isValid();    
 
-    void setSource(QString&);
-    QString source();
+    void setSource(const QByteArray&);
+    QByteArray source();
 
     void clear();
 
@@ -32,7 +32,7 @@ class Response
 
 private:
 
-    QString responseString;
+    QByteArray responseSource;
 
     //type
     enum ResponseType 
@@ -44,24 +44,24 @@ class Response
     int lastValidPos;
     int itemsCount;
 
-    ResponseType getResponseType(const QString&) const;    
-    ResponseType getResponseType(const QChar) const;
+    ResponseType getResponseType(const QByteArray&) const;    
+    ResponseType getResponseType(const char) const;
 
     //parsers
-    QVariant parseBulk(const QString& response);
-    QStringList parseMultiBulk(const QString& response);
-    QString getStringResponse(QString response);
+    QString parseBulk(const QByteArray& response);
+    QStringList parseMultiBulk(const QByteArray& response);
+    QString getStringResponse(const QByteArray& response);
 
-    int getSizeOfBulkReply(const QString& reply, int endOfFirstLine = -1, int beginFrom = 0);    
+    int getSizeOfBulkReply(const QByteArray& reply, int endOfFirstLine = -1, int beginFrom = 0);    
 
     //validations
-    bool isReplyValid(const QString&);
+    bool isReplyValid(const QByteArray&);
 
     /** checks general validation rules **/
-    bool isReplyGeneralyValid(const QString& );
-    bool isIntReplyValid(const QString&);
-    bool isBulkReplyValid(const QString&);
-    bool isMultiBulkReplyValid(const QString&);    
+    bool isReplyGeneralyValid(const QByteArray& );
+    bool isIntReplyValid(const QByteArray&);
+    bool isBulkReplyValid(const QByteArray&);
+    bool isMultiBulkReplyValid(const QByteArray&);    
 
-    int getPosOfNextItem(const QString &, int);
+    int getPosOfNextItem(const QByteArray &, int);
 };
diff --git a/redis-desktop-manager/source/redis/Response.cpp b/redis-desktop-manager/source/redis/Response.cpp
@@ -2,73 +2,73 @@
 #include "RedisException.h"
 
 Response::Response()
-    : responseString(""), lastValidPos(0), itemsCount(0)
+    : responseSource(""), lastValidPos(0), itemsCount(0)
 {
 }
 
-Response::Response(QString & src)
-    : responseString(src), lastValidPos(0), itemsCount(0)
+Response::Response(const QByteArray & src)
+    : responseSource(src), lastValidPos(0), itemsCount(0)
 {
 }
 
 Response::~Response(void)
 {
 }
 
-void Response::setSource(QString& str)
+void Response::setSource(const QByteArray& src)
 {
-    responseString = str;
+    responseSource = src;
 }
 
 void Response::clear()
 {
-    responseString.clear();
+    responseSource.clear();
     lastValidPos = 0;
     itemsCount = 0;
 }
 
-QString Response::source()
+QByteArray Response::source()
 {
-    return responseString;
+    return responseSource;
 }
 
 void Response::appendToSource(QString& src)
 {
-    responseString.append(src);
+    responseSource.append(src);
 }
 
 void Response::appendToSource(QByteArray& src)
 {
-    responseString.append(src);
+    responseSource.append(src);
 }
 
 QVariant Response::getValue()
 {
-    if (responseString.isEmpty()) {
+    if (responseSource.isEmpty()) {
         return QVariant();
     }
 
-    ResponseType t = getResponseType(responseString);
+    ResponseType t = getResponseType(responseSource);
 
     QVariant  parsedResponse;
 
     switch (t) {
 
     case Status:
     case Error:        
-        parsedResponse = QVariant(getStringResponse(responseString));
+        parsedResponse = QVariant(getStringResponse(responseSource));
         break;
 
     case Integer:        
-        parsedResponse = QVariant(getStringResponse(responseString).toInt());
+        parsedResponse = QVariant(getStringResponse(responseSource).toInt());
         break;
 
     case Bulk:
-        parsedResponse = parseBulk(responseString);
+        parsedResponse = QVariant(parseBulk(responseSource));
         break;
 
     case MultiBulk: 
-        parsedResponse = QVariant(parseMultiBulk(responseString));        
+        parsedResponse = QVariant(parseMultiBulk(responseSource));        
         break;
     case Unknown:
         break;
@@ -77,19 +77,19 @@ QVariant Response::getValue()
     return parsedResponse;
 }    
 
-QVariant Response::parseBulk(const QString& response)
+QString Response::parseBulk(const QByteArray& response)
 {
     int endOfFirstLine = response.indexOf("\r\n");
     int responseSize = getSizeOfBulkReply(response, endOfFirstLine);    
 
     if (responseSize != -1) {
-        return QVariant(response.mid(endOfFirstLine + 2, responseSize));        
+        return response.mid(endOfFirstLine + 2, responseSize);        
     }
 
-    return QVariant();
+    return "";
 }
 
-QStringList Response::parseMultiBulk(const QString& response)
+QStringList Response::parseMultiBulk(const QByteArray& response)
 {    
     int endOfFirstLine = response.indexOf("\r\n");
     int responseSize = getSizeOfBulkReply(response, endOfFirstLine);            
@@ -138,12 +138,12 @@ QStringList Response::parseMultiBulk(const QString& response)
     return parsedResult;
 }
 
-Response::ResponseType Response::getResponseType(const QString & r) const
+Response::ResponseType Response::getResponseType(const QByteArray & r) const
 {    
     return getResponseType(r.at(0));
 }
 
-Response::ResponseType Response::getResponseType(const QChar typeChar) const
+Response::ResponseType Response::getResponseType(const char typeChar) const
 {    
     if (typeChar == '+') return Status; 
     if (typeChar == '-') return Error;
@@ -154,17 +154,17 @@ Response::ResponseType Response::getResponseType(const QChar typeChar) const
     return Unknown;
 }
 
-QString Response::getStringResponse(QString response)
+QString Response::getStringResponse(const QByteArray& response)
 {
-    return     response.mid(1, response.length() - 3);
+    return response.mid(1, response.length() - 3);
 }
 
 bool Response::isValid()
 {
-    return isReplyValid(responseString);
+    return isReplyValid(responseSource);
 }
 
-bool Response::isReplyValid(const QString & responseString)
+bool Response::isReplyValid(const QByteArray & responseString)
 {
     if (responseString.isEmpty()) 
     {
@@ -195,12 +195,12 @@ bool Response::isReplyValid(const QString & responseString)
     }    
 }
 
-bool Response::isReplyGeneralyValid(const QString& r)
+bool Response::isReplyGeneralyValid(const QByteArray& r)
 {
     return r.endsWith("\r\n");
 }
 
-int Response::getPosOfNextItem(const QString &r, int startPos = 0)
+int Response::getPosOfNextItem(const QByteArray &r, int startPos = 0)
 {
     if (startPos >= r.size()) {
         return -1;
@@ -232,12 +232,12 @@ int Response::getPosOfNextItem(const QString &r, int startPos = 0)
 
 }
 
-bool Response::isIntReplyValid(const QString& r)
+bool Response::isIntReplyValid(const QByteArray& r)
 {
     return !r.isEmpty();
 }
 
-bool Response::isBulkReplyValid(const QString& r)
+bool Response::isBulkReplyValid(const QByteArray& r)
 {            
     int endOfFirstLine = r.indexOf("\r\n");
     int responseSize = getSizeOfBulkReply(r, endOfFirstLine);
@@ -256,7 +256,7 @@ bool Response::isBulkReplyValid(const QString& r)
     return true;
 }
 
-bool Response::isMultiBulkReplyValid(const QString& r) 
+bool Response::isMultiBulkReplyValid(const QByteArray& r) 
 {    
     int endOfFirstLine = r.indexOf("\r\n");
     int responseSize = getSizeOfBulkReply(r, endOfFirstLine);
@@ -300,7 +300,7 @@ bool Response::isMultiBulkReplyValid(const QString& r)
     return true;    
 }
 
-int Response::getSizeOfBulkReply(const QString& reply, int endOfFirstLine, int beginFrom) 
+int Response::getSizeOfBulkReply(const QByteArray& reply, int endOfFirstLine, int beginFrom) 
 {
     if (endOfFirstLine == -1) {
         endOfFirstLine = reply.indexOf("\r\n", beginFrom);
@@ -334,7 +334,7 @@ int Response::getLoadedItemsCount()
 
 bool Response::isErrorMessage() const
 {
-    return getResponseType(responseString) == Error
-        && responseString.startsWith("-ERR");
+    return getResponseType(responseSource) == Error
+        && responseSource.startsWith("-ERR");
 
 }

Original file line number	Diff line number	Diff line change
`@@ -2,73 +2,73 @@`
`2`	`2`	`#include "RedisException.h"`
`3`	`3`
`4`	`4`	`Response::Response()`
`5`		`- : responseString(""), lastValidPos(0), itemsCount(0)`
	`5`	`+ : responseSource(""), lastValidPos(0), itemsCount(0)`
`6`	`6`	`{`
`7`	`7`	`}`
`8`	`8`
`9`		`-Response::Response(QString & src)`
`10`		`- : responseString(src), lastValidPos(0), itemsCount(0)`
	`9`	`+Response::Response(const QByteArray & src)`
	`10`	`+ : responseSource(src), lastValidPos(0), itemsCount(0)`
`11`	`11`	`{`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`Response::~Response(void)`
`15`	`15`	`{`
`16`	`16`	`}`
`17`	`17`
`18`		`-void Response::setSource(QString& str)`
	`18`	`+void Response::setSource(const QByteArray& src)`
`19`	`19`	`{`
`20`		`- responseString = str;`
	`20`	`+ responseSource = src;`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`void Response::clear()`
`24`	`24`	`{`
`25`		`- responseString.clear();`
	`25`	`+ responseSource.clear();`
`26`	`26`	`lastValidPos = 0;`
`27`	`27`	`itemsCount = 0;`
`28`	`28`	`}`
`29`	`29`
`30`		`-QString Response::source()`
	`30`	`+QByteArray Response::source()`
`31`	`31`	`{`
`32`		`- return responseString;`
	`32`	`+ return responseSource;`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`void Response::appendToSource(QString& src)`
`36`	`36`	`{`
`37`		`- responseString.append(src);`
	`37`	`+ responseSource.append(src);`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`void Response::appendToSource(QByteArray& src)`
`41`	`41`	`{`
`42`		`- responseString.append(src);`
	`42`	`+ responseSource.append(src);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`QVariant Response::getValue()`
`46`	`46`	`{`
`47`		`- if (responseString.isEmpty()) {`
	`47`	`+ if (responseSource.isEmpty()) {`
`48`	`48`	`return QVariant();`
`49`	`49`	`}`
`50`	`50`
`51`		`- ResponseType t = getResponseType(responseString);`
	`51`	`+ ResponseType t = getResponseType(responseSource);`
`52`	`52`
`53`	`53`	`QVariant parsedResponse;`
`54`	`54`
`55`	`55`	`switch (t) {`
`56`	`56`
`57`	`57`	`case Status:`
`58`	`58`	`case Error:`
`59`		`- parsedResponse = QVariant(getStringResponse(responseString));`
	`59`	`+ parsedResponse = QVariant(getStringResponse(responseSource));`
`60`	`60`	`break;`
`61`	`61`
`62`	`62`	`case Integer:`
`63`		`- parsedResponse = QVariant(getStringResponse(responseString).toInt());`
	`63`	`+ parsedResponse = QVariant(getStringResponse(responseSource).toInt());`
`64`	`64`	`break;`
`65`	`65`
`66`	`66`	`case Bulk:`
`67`		`- parsedResponse = parseBulk(responseString);`
	`67`	`+ parsedResponse = QVariant(parseBulk(responseSource));`
`68`	`68`	`break;`
`69`	`69`
`70`	`70`	`case MultiBulk:`
`71`		`- parsedResponse = QVariant(parseMultiBulk(responseString));`
	`71`	`+ parsedResponse = QVariant(parseMultiBulk(responseSource));`
`72`	`72`	`break;`
`73`	`73`	`case Unknown:`
`74`	`74`	`break;`
`@@ -77,19 +77,19 @@ QVariant Response::getValue()`
`77`	`77`	`return parsedResponse;`
`78`	`78`	`}`
`79`	`79`
`80`		`-QVariant Response::parseBulk(const QString& response)`
	`80`	`+QString Response::parseBulk(const QByteArray& response)`
`81`	`81`	`{`
`82`	`82`	`int endOfFirstLine = response.indexOf("\r\n");`
`83`	`83`	`int responseSize = getSizeOfBulkReply(response, endOfFirstLine);`
`84`	`84`
`85`	`85`	`if (responseSize != -1) {`
`86`		`- return QVariant(response.mid(endOfFirstLine + 2, responseSize));`
	`86`	`+ return response.mid(endOfFirstLine + 2, responseSize);`
`87`	`87`	`}`
`88`	`88`
`89`		`- return QVariant();`
	`89`	`+ return "";`
`90`	`90`	`}`
`91`	`91`
`92`		`-QStringList Response::parseMultiBulk(const QString& response)`
	`92`	`+QStringList Response::parseMultiBulk(const QByteArray& response)`
`93`	`93`	`{`
`94`	`94`	`int endOfFirstLine = response.indexOf("\r\n");`
`95`	`95`	`int responseSize = getSizeOfBulkReply(response, endOfFirstLine);`
`@@ -138,12 +138,12 @@ QStringList Response::parseMultiBulk(const QString& response)`
`138`	`138`	`return parsedResult;`
`139`	`139`	`}`
`140`	`140`
`141`		`-Response::ResponseType Response::getResponseType(const QString & r) const`
	`141`	`+Response::ResponseType Response::getResponseType(const QByteArray & r) const`
`142`	`142`	`{`
`143`	`143`	`return getResponseType(r.at(0));`
`144`	`144`	`}`
`145`	`145`
`146`		`-Response::ResponseType Response::getResponseType(const QChar typeChar) const`
	`146`	`+Response::ResponseType Response::getResponseType(const char typeChar) const`
`147`	`147`	`{`
`148`	`148`	`if (typeChar == '+') return Status;`
`149`	`149`	`if (typeChar == '-') return Error;`
`@@ -154,17 +154,17 @@ Response::ResponseType Response::getResponseType(const QChar typeChar) const`
`154`	`154`	`return Unknown;`
`155`	`155`	`}`
`156`	`156`
`157`		`-QString Response::getStringResponse(QString response)`
	`157`	`+QString Response::getStringResponse(const QByteArray& response)`
`158`	`158`	`{`
`159`		`- return response.mid(1, response.length() - 3);`
	`159`	`+ return response.mid(1, response.length() - 3);`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`bool Response::isValid()`
`163`	`163`	`{`
`164`		`- return isReplyValid(responseString);`
	`164`	`+ return isReplyValid(responseSource);`
`165`	`165`	`}`
`166`	`166`
`167`		`-bool Response::isReplyValid(const QString & responseString)`
	`167`	`+bool Response::isReplyValid(const QByteArray & responseString)`
`168`	`168`	`{`
`169`	`169`	`if (responseString.isEmpty())`
`170`	`170`	`{`
`@@ -195,12 +195,12 @@ bool Response::isReplyValid(const QString & responseString)`
`195`	`195`	`}`
`196`	`196`	`}`
`197`	`197`
`198`		`-bool Response::isReplyGeneralyValid(const QString& r)`
	`198`	`+bool Response::isReplyGeneralyValid(const QByteArray& r)`
`199`	`199`	`{`
`200`	`200`	`return r.endsWith("\r\n");`
`201`	`201`	`}`
`202`	`202`
`203`		`-int Response::getPosOfNextItem(const QString &r, int startPos = 0)`
	`203`	`+int Response::getPosOfNextItem(const QByteArray &r, int startPos = 0)`
`204`	`204`	`{`
`205`	`205`	`if (startPos >= r.size()) {`
`206`	`206`	`return -1;`
`@@ -232,12 +232,12 @@ int Response::getPosOfNextItem(const QString &r, int startPos = 0)`
`232`	`232`
`233`	`233`	`}`
`234`	`234`
`235`		`-bool Response::isIntReplyValid(const QString& r)`
	`235`	`+bool Response::isIntReplyValid(const QByteArray& r)`
`236`	`236`	`{`
`237`	`237`	`return !r.isEmpty();`
`238`	`238`	`}`
`239`	`239`
`240`		`-bool Response::isBulkReplyValid(const QString& r)`
	`240`	`+bool Response::isBulkReplyValid(const QByteArray& r)`
`241`	`241`	`{`
`242`	`242`	`int endOfFirstLine = r.indexOf("\r\n");`
`243`	`243`	`int responseSize = getSizeOfBulkReply(r, endOfFirstLine);`
`@@ -256,7 +256,7 @@ bool Response::isBulkReplyValid(const QString& r)`
`256`	`256`	`return true;`
`257`	`257`	`}`
`258`	`258`
`259`		`-bool Response::isMultiBulkReplyValid(const QString& r)`
	`259`	`+bool Response::isMultiBulkReplyValid(const QByteArray& r)`
`260`	`260`	`{`
`261`	`261`	`int endOfFirstLine = r.indexOf("\r\n");`
`262`	`262`	`int responseSize = getSizeOfBulkReply(r, endOfFirstLine);`
`@@ -300,7 +300,7 @@ bool Response::isMultiBulkReplyValid(const QString& r)`
`300`	`300`	`return true;`
`301`	`301`	`}`
`302`	`302`
`303`		`-int Response::getSizeOfBulkReply(const QString& reply, int endOfFirstLine, int beginFrom)`
	`303`	`+int Response::getSizeOfBulkReply(const QByteArray& reply, int endOfFirstLine, int beginFrom)`
`304`	`304`	`{`
`305`	`305`	`if (endOfFirstLine == -1) {`
`306`	`306`	`endOfFirstLine = reply.indexOf("\r\n", beginFrom);`
`@@ -334,7 +334,7 @@ int Response::getLoadedItemsCount()`
`334`	`334`
`335`	`335`	`bool Response::isErrorMessage() const`
`336`	`336`	`{`
`337`		`- return getResponseType(responseString) == Error`
`338`		`- && responseString.startsWith("-ERR");`
	`337`	`+ return getResponseType(responseSource) == Error`
	`338`	`+ && responseSource.startsWith("-ERR");`
`339`	`339`
`340`	`340`	`}`