Simplify natural sort classes interface

Now the comparison function/class should be constructed before usage.
This change also make it easier to plug in into various containers which
will require a compare function type (such as std::set).

src/base/utils/compare.cpp

@@ -0,0 +1,96 @@
+/*
+ * Bittorrent Client using Qt and libtorrent.
+ * Copyright (C) 2021  Mike Tzou (Chocobo1)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * In addition, as a special exception, the copyright holders give permission to
+ * link this program with the OpenSSL project's "OpenSSL" library (or with
+ * modified versions of it that use the same license as the "OpenSSL" library),
+ * and distribute the linked executables. You must obey the GNU General Public
+ * License in all respects for all of the code used other than "OpenSSL".  If you
+ * modify file(s), you may extend this exception to your version of the file(s),
+ * but you are not obligated to do so. If you do not wish to do so, delete this
+ * exception statement from your version.
+ */
+
+#include "compare.h"
+
+#include <QChar>
+#include <QString>
+
+#ifndef QBT_USE_QCOLLATOR
+int Utils::Compare::naturalCompare(const QString &left, const QString &right, const Qt::CaseSensitivity caseSensitivity)
+{
+    // Return value <0: `left` is smaller than `right`
+    // Return value >0: `left` is greater than `right`
+    // Return value =0: both strings are equal
+
+    int posL = 0;
+    int posR = 0;
+    while (true)
+    {
+        if ((posL == left.size()) || (posR == right.size()))
+            return (left.size() - right.size());  // when a shorter string is another string's prefix, shorter string place before longer string
+
+        const QChar leftChar = (caseSensitivity == Qt::CaseSensitive) ? left[posL] : left[posL].toLower();
+        const QChar rightChar = (caseSensitivity == Qt::CaseSensitive) ? right[posR] : right[posR].toLower();
+        // Compare only non-digits.
+        // Numbers should be compared as a whole
+        // otherwise the string->int conversion can yield a wrong value
+        if ((leftChar == rightChar) && !leftChar.isDigit())
+        {
+            // compare next character
+            ++posL;
+            ++posR;
+        }
+        else if (leftChar.isDigit() && rightChar.isDigit())
+        {
+            // Both are digits, compare the numbers
+
+            const auto numberView = [](const QString &str, int &pos) -> QStringRef
+            {
+                const int start = pos;
+                while ((pos < str.size()) && str[pos].isDigit())
+                    ++pos;
+                return str.midRef(start, (pos - start));
+            };
+
+            const QStringRef numViewL = numberView(left, posL);
+            const QStringRef numViewR = numberView(right, posR);
+
+            if (numViewL.length() != numViewR.length())
+                return (numViewL.length() - numViewR.length());
+
+            // both string/view has the same length
+            for (int i = 0; i < numViewL.length(); ++i)
+            {
+                const QChar numL = numViewL[i];
+                const QChar numR = numViewR[i];
+
+                if (numL != numR)
+                    return (numL.unicode() - numR.unicode());
+            }
+
+            // String + digits do match and we haven't hit the end of both strings
+            // then continue to consume the remainings
+        }
+        else
+        {
+            return (leftChar.unicode() - rightChar.unicode());
+        }
+    }
+}
+#endif