Add explicit encode()/decode() methods to QStringConverter

The functional style interface is nice, but does feel alien in some
contexts, so better also have explicit encode and decode methods.

Change-Id: Ic07ced15f65cdb3a7f1cf044041e341d2ef87f79
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>

src/corelib/text/qstringconverter.cpp

@@ -1785,12 +1785,14 @@ const char *QStringConverter::nameForEncoding(QStringConverter::Encoding e)
 
 /*!
     \fn QByteArray QStringEncoder::operator()(const QString &in)
+    \fn QByteArray QStringEncoder::encode(const QString &in)
 
     Converts \a in and returns the data as a byte array.
 */
 
 /*!
     \fn QByteArray QStringEncoder::operator()(QStringView in)
+    \fn QByteArray QStringEncoder::encode(QStringView in)
     \overload
 
     Converts \a in and returns the data as a byte array.
@@ -1798,6 +1800,7 @@ const char *QStringConverter::nameForEncoding(QStringConverter::Encoding e)
 
 /*!
     \fn QByteArray QStringEncoder::operator()(const QChar *in, qsizetype length)
+    \fn QByteArray QStringEncoder::encode(const QChar *in, qsizetype length)
     \overload
 
     Converts \a length QChars from \a in and returns the data as a byte array.
@@ -1885,12 +1888,14 @@ const char *QStringConverter::nameForEncoding(QStringConverter::Encoding e)
 
 /*!
     \fn QString QStringDecoder::operator()(const QByteArray &ba)
+    \fn QString QStringDecoder::decode(const QByteArray &ba)
 
     Converts \a ba and returns the data as a QString.
 */
 
 /*!
     \fn QString QStringDecoder::operator()(const char *in, qsizetype size)
+    \fn QString QStringDecoder::decode(const char *in, qsizetype size)
     \overload
 
     Converts a byte array containing the first \a size bytes of the array \a in
@@ -1899,6 +1904,7 @@ const char *QStringConverter::nameForEncoding(QStringConverter::Encoding e)
 
 /*!
     \fn QString QStringDecoder::operator()(const char *chars)
+    \fn QString QStringDecoder::decode(const char *chars)
     \overload
 
     Converts \a chars and returns the data as a QString. \a chars is assumed to

src/corelib/text/qstringconverter.h

@@ -210,13 +210,16 @@ public:
     QByteArray operator()(const QString &in);
     QByteArray operator()(QStringView in);
     QByteArray operator()(const QChar *in, qsizetype length);
+    QByteArray encode(const QString &in);
+    QByteArray encode(QStringView in);
+    QByteArray encode(const QChar *in, qsizetype length);
 #else
     template<typename T>
     struct DecodedData
     {
         QStringEncoder *encoder;
         T data;
-        operator QByteArray() const { return encoder->encode(QStringView(data)); }
+        operator QByteArray() const { return encoder->encodeAsByteArray(QStringView(data)); }
     };
     DecodedData<const QString &> operator()(const QString &str)
     { return DecodedData<const QString &>{this, str}; }
@@ -224,6 +227,12 @@ public:
     { return DecodedData<QStringView>{this, in}; }
     DecodedData<QStringView> operator()(const QChar *in, qsizetype length)
     { return (*this)(QStringView(in, length)); }
+    DecodedData<const QString &> encode(const QString &str)
+    { return DecodedData<const QString &>{this, str}; }
+    DecodedData<QStringView> encode(QStringView in)
+    { return DecodedData<QStringView>{this, in}; }
+    DecodedData<QStringView> encode(const QChar *in, qsizetype length)
+    { return (*this)(QStringView(in, length)); }
 #endif
 
     qsizetype requiredSpace(qsizetype inputLength) const
@@ -231,7 +240,7 @@ public:
     char *appendToBuffer(char *out, const QChar *in, qsizetype length)
     { return iface->fromUtf16(out, QStringView(in, length), &state); }
 private:
-    QByteArray encode(QStringView in)
+    QByteArray encodeAsByteArray(QStringView in)
     {
         QByteArray result(iface->fromUtf16Len(in.size()), Qt::Uninitialized);
         char *out = result.data();
@@ -270,13 +279,16 @@ public:
     QString operator()(const QByteArray &ba);
     QString operator()(const char *in, qsizetype size);
     QString operator()(const char *chars);
+    QString decode(const QByteArray &ba);
+    QString decode(const char *in, qsizetype size);
+    QString decode(const char *chars);
 #else
     template<typename T>
     struct EncodedData
     {
         QStringDecoder *decoder;
         T data;
-        operator QString() const { return decoder->decode(data.data(), data.length()); }
+        operator QString() const { return decoder->decodeAsString(data.data(), data.length()); }
     };
     EncodedData<const QByteArray &> operator()(const QByteArray &ba)
     { return EncodedData<const QByteArray &>{this, ba}; }
@@ -284,6 +296,12 @@ public:
     { return EncodedData<View>{this, {in, length}}; }
     EncodedData<View> operator()(const char *chars)
     { return EncodedData<View>{this, {chars, qsizetype(strlen(chars))}}; }
+    EncodedData<const QByteArray &> decode(const QByteArray &ba)
+    { return EncodedData<const QByteArray &>{this, ba}; }
+    EncodedData<View> decode(const char *in, qsizetype length)
+    { return EncodedData<View>{this, {in, length}}; }
+    EncodedData<View> decode(const char *chars)
+    { return EncodedData<View>{this, {chars, qsizetype(strlen(chars))}}; }
 #endif
 
     qsizetype requiredSpace(qsizetype inputLength) const
@@ -291,7 +309,7 @@ public:
     QChar *appendToBuffer(QChar *out, const char *in, qsizetype length)
     { return iface->toUtf16(out, in, length, &state); }
 private:
-    QString decode(const char *in, qsizetype length)
+    QString decodeAsString(const char *in, qsizetype length)
     {
         QString result(iface->toUtf16Len(length), Qt::Uninitialized);
         QChar *out  = result.data();

tests/auto/corelib/text/qstringconverter/tst_qstringconverter.cpp

@@ -114,9 +114,13 @@ void tst_QStringConverter::convertUtf8()
         QString uniString = decoder(ba);
         QCOMPARE(uniString, QString::fromUtf8(ba));
         QCOMPARE(ba, uniString.toUtf8());
+        uniString = decoder.decode(ba);
+        QCOMPARE(uniString, QString::fromUtf8(ba));
+        QCOMPARE(ba, uniString.toUtf8());
 
         QStringEncoder encoder(QStringEncoder::Utf8);
         QCOMPARE(ba, encoder(uniString));
+        QCOMPARE(ba, encoder.encode(uniString));
     }
 
     {
@@ -127,12 +131,20 @@ void tst_QStringConverter::convertUtf8()
         for (int i = 0; i < ba.size(); ++i)
             uniString += decoder(ba.constData() + i, 1);
         QCOMPARE(uniString, QString::fromUtf8(ba));
+        uniString.clear();
+        for (int i = 0; i < ba.size(); ++i)
+            uniString += decoder.decode(ba.constData() + i, 1);
+        QCOMPARE(uniString, QString::fromUtf8(ba));
 
         QStringEncoder encoder(QStringEncoder::Utf8);
         QByteArray reencoded;
         for (int i = 0; i < uniString.size(); ++i)
             reencoded += encoder(uniString.constData() + i, 1);
         QCOMPARE(ba, encoder(uniString));
+        reencoded.clear();
+        for (int i = 0; i < uniString.size(); ++i)
+            reencoded += encoder.encode(uniString.constData() + i, 1);
+        QCOMPARE(ba, encoder(uniString));
     }
 }