okular/generators/comicbook/qnatsort.cpp

/*
    Natural order sorting of strings which contains numbers.

    SPDX-FileCopyrightText: 2007 Tobias Koenig <tokoe@kde.org>
    SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only
    based on the natural order code by Martin Pool <mbp sourcefrog net>
*/

#include "qnatsort.h"

static int compare_right(const QString &leftStr, int left, const QString &rightStr, int right)
{
    int bias = 0;

    /**
     * The longest run of digits wins.  That aside, the greatest
     * value wins, but we can't know that it will until we've scanned
     * both numbers to know that they have the same magnitude, so we
     * remember it in BIAS.
     */
    for (;; left++, right++) {
        if (left >= leftStr.length() && right < rightStr.length()) {
            return -1;
        } else if (right >= rightStr.length() && left < leftStr.length()) {
            return +1;
        } else if (right >= rightStr.length() && left >= leftStr.length()) {
            return bias;
        } else if (!leftStr[left].isDigit() && !rightStr[right].isDigit()) {
            return bias;
        } else if (!leftStr[left].isDigit()) {
            return -1;
        } else if (!rightStr[right].isDigit()) {
            return +1;
        } else if (leftStr[left] < rightStr[right]) {
            if (!bias) {
                bias = -1;
            }
        } else if (leftStr[left] > rightStr[right]) {
            if (!bias) {
                bias = +1;
            }
        } else if (leftStr[left].isNull() && rightStr[right].isNull()) {
            return bias;
        }
    }

    return 0;
}

static int compare_left(const QString &leftStr, int left, const QString &rightStr, int right)
{
    /**
     * Compare two left-aligned numbers: the first to have a
     * different value wins.
     */
    for (;; left++, right++) {
        if (left >= leftStr.length() && right < rightStr.length()) {
            return -1;
        } else if (right >= rightStr.length() && left < leftStr.length()) {
            return +1;
        } else if (right >= rightStr.length() && left >= leftStr.length()) {
            return 0;
        } else if (!leftStr[left].isDigit() && !rightStr[right].isDigit()) {
            return 0;
        } else if (!leftStr[left].isDigit()) {
            return -1;
        } else if (!rightStr[right].isDigit()) {
            return +1;
        } else if (leftStr[left] < rightStr[right]) {
            return -1;
        } else if (leftStr[left] > rightStr[right]) {
            return +1;
        }
    }

    return 0;
}

static int natural_order_compare(const QString &leftStr, const QString &rightStr, bool fold_case)
{
    if (leftStr.isEmpty() && rightStr.isEmpty()) {
        return 0;
    }

    int ai, bi;
    QChar ca, cb;
    int fractional, result;

    ai = bi = 0;
    const int aSize = leftStr.size();
    const int bSize = rightStr.size();

    while (true) {
        ca = leftStr[ai];
        cb = rightStr[bi];

        /* skip over leading spaces or zeros */
        while (ca.isSpace() && ++ai < aSize) {
            ca = leftStr[ai];
        }

        while (cb.isSpace() && ++bi < bSize) {
            cb = rightStr[bi];
        }

        /* process run of digits */
        if (ca.isDigit() && cb.isDigit()) {
            fractional = (ca == QLatin1Char('0') || cb == QLatin1Char('0'));

            if (fractional) {
                if ((result = compare_left(leftStr, ai, rightStr, bi)) != 0) {
                    return result;
                }
            } else {
                if ((result = compare_right(leftStr, ai, rightStr, bi)) != 0) {
                    return result;
                }
            }
        }

        if (ca.isNull() && cb.isNull()) {
            /* The strings compare the same.  Perhaps the caller
               will want to call strcmp to break the tie. */
            return 0;
        }

        if (fold_case) {
            ca = ca.toUpper();
            cb = cb.toUpper();
        }

        if (ca < cb) {
            return -1;
        } else if (ca > cb) {
            return +1;
        }

        ++ai;
        ++bi;
        if (aSize == ai) {
            return aSize <= bSize ? -1 : 1;
        }
        if (bSize == bi) {
            return bSize <= aSize ? 1 : -1;
        }
    }
}

bool caseSensitiveNaturalOrderLessThen(const QString &left, const QString &right)
{
    return (natural_order_compare(left, right, false) < 0);
}

bool caseInsensitiveNaturalOrderLessThen(const QString &left, const QString &right)
{
    return (natural_order_compare(left, right, true) < 0);
}