chore: change qt version

3rdparty/base64.cpp

@@ -0,0 +1,88 @@
+#include "base64.h"
+
+namespace Qt515Base64 {
+    namespace {
+        struct fromBase64_helper_result {
+            qsizetype decodedLength;
+            Base64DecodingStatus status;
+        };
+
+        fromBase64_helper_result fromBase64_helper(const char *input, qsizetype inputSize,
+                                                   char *output /* may alias input */,
+                                                   Base64Options options) {
+            fromBase64_helper_result result{0, Base64DecodingStatus::Ok};
+
+            unsigned int buf = 0;
+            int nbits = 0;
+
+            qsizetype offset = 0;
+            for (qsizetype i = 0; i < inputSize; ++i) {
+                int ch = input[i];
+                int d;
+
+                if (ch >= 'A' && ch <= 'Z') {
+                    d = ch - 'A';
+                } else if (ch >= 'a' && ch <= 'z') {
+                    d = ch - 'a' + 26;
+                } else if (ch >= '0' && ch <= '9') {
+                    d = ch - '0' + 52;
+                } else if (ch == '+' && (options & Base64UrlEncoding) == 0) {
+                    d = 62;
+                } else if (ch == '-' && (options & Base64UrlEncoding) != 0) {
+                    d = 62;
+                } else if (ch == '/' && (options & Base64UrlEncoding) == 0) {
+                    d = 63;
+                } else if (ch == '_' && (options & Base64UrlEncoding) != 0) {
+                    d = 63;
+                } else {
+                    if (options & AbortOnBase64DecodingErrors) {
+                        if (ch == '=') {
+                            // can have 1 or 2 '=' signs, in both cases padding base64Size to
+                            // a multiple of 4. Any other case is illegal.
+                            if ((inputSize % 4) != 0) {
+                                result.status = Base64DecodingStatus::IllegalInputLength;
+                                return result;
+                            } else if ((i == inputSize - 1) ||
+                                       (i == inputSize - 2 && input[++i] == '=')) {
+                                d = -1; // ... and exit the loop, normally
+                            } else {
+                                result.status = Base64DecodingStatus::IllegalPadding;
+                                return result;
+                            }
+                        } else {
+                            result.status = Base64DecodingStatus::IllegalCharacter;
+                            return result;
+                        }
+                    } else {
+                        d = -1;
+                    }
+                }
+
+                if (d != -1) {
+                    buf = (buf << 6) | d;
+                    nbits += 6;
+                    if (nbits >= 8) {
+                        nbits -= 8;
+                        Q_ASSERT(offset < i);
+                        output[offset++] = buf >> nbits;
+                        buf &= (1 << nbits) - 1;
+                    }
+                }
+            }
+
+            result.decodedLength = offset;
+            return result;
+        }
+    } // namespace
+
+    FromBase64Result QByteArray_fromBase64Encoding(const QByteArray &base64, Base64Options options) {
+        const auto base64Size = base64.size();
+        QByteArray result((base64Size * 3) / 4, Qt::Uninitialized);
+        const auto base64result = fromBase64_helper(base64.data(),
+                                                    base64Size,
+                                                    const_cast<char *>(result.constData()),
+                                                    options);
+        result.truncate(int(base64result.decodedLength));
+        return {std::move(result), base64result.status};
+    }
+} // namespace Qt515Base64

3rdparty/base64.h

@@ -0,0 +1,47 @@
+#include <QByteArray>
+
+namespace Qt515Base64 {
+    enum Base64Option {
+        Base64Encoding = 0,
+        Base64UrlEncoding = 1,
+
+        KeepTrailingEquals = 0,
+        OmitTrailingEquals = 2,
+
+        IgnoreBase64DecodingErrors = 0,
+        AbortOnBase64DecodingErrors = 4,
+    };
+    Q_DECLARE_FLAGS(Base64Options, Base64Option)
+    Q_DECLARE_OPERATORS_FOR_FLAGS(Base64Options)
+
+    enum class Base64DecodingStatus {
+        Ok,
+        IllegalInputLength,
+        IllegalCharacter,
+        IllegalPadding,
+    };
+
+    class FromBase64Result {
+    public:
+        QByteArray decoded;
+        Base64DecodingStatus decodingStatus;
+
+        void swap(FromBase64Result &other) noexcept {
+            qSwap(decoded, other.decoded);
+            qSwap(decodingStatus, other.decodingStatus);
+        }
+
+        explicit operator bool() const noexcept { return decodingStatus == Base64DecodingStatus::Ok; }
+
+#if defined(Q_COMPILER_REF_QUALIFIERS) && !defined(Q_QDOC)
+        QByteArray &operator*() &noexcept { return decoded; }
+        const QByteArray &operator*() const &noexcept { return decoded; }
+        QByteArray &&operator*() &&noexcept { return std::move(decoded); }
+#else
+        QByteArray &operator*() noexcept { return decoded; }
+        const QByteArray &operator*() const noexcept { return decoded; }
+#endif
+    };
+
+    FromBase64Result QByteArray_fromBase64Encoding(const QByteArray &base64, Base64Options options);
+} // namespace Qt515Base64