mythsorthelper.cpp

Go to the documentation of this file.

// -*- Mode: c++ -*-
// vim: set expandtab tabstop=4 shiftwidth=4
 
#include "mythsorthelper.h"
 
#include "mythcorecontext.h"
 
void MythSortHelper::MythSortHelperCommon(void)
{
    m_prefixes = tr("^(The |A |An )",
                    "Regular Expression for what to ignore when sorting");
    m_prefixes = m_prefixes.trimmed();
    if (not hasPrefixes()) {
        // This language doesn't ignore any words when sorting
        m_prefixMode = SortPrefixKeep;
        return;
    }
    if (not m_prefixes.startsWith("^"))
        m_prefixes = "^" + m_prefixes;
 
    if (m_caseSensitive == Qt::CaseInsensitive)
    {
        m_prefixes = m_prefixes.toLower();
        m_exclusions = m_exclusions.toLower();
    }
    m_prefixesRegex = QRegularExpression(m_prefixes);
    m_prefixesRegex2 = QRegularExpression(m_prefixes + "(.*)");
#if QT_VERSION < QT_VERSION_CHECK(5,14,0)
    m_exclList = m_exclusions.split(";", QString::SkipEmptyParts);
#else
    m_exclList = m_exclusions.split(";", Qt::SkipEmptyParts);
#endif
    for (int i = 0; i < m_exclList.size(); i++)
      m_exclList[i] = m_exclList[i].trimmed();
}
 
MythSortHelper::MythSortHelper()
{
    if (gCoreContext) {
#if 0
        // Last minute change.  QStringRef::localeAwareCompare appears to
        // always do case insensitive sorting, so there's no point in
        // presenting this option to a user.
        m_caseSensitive =
            gCoreContext->GetBoolSetting("SortCaseSensitive", false)
            ? Qt::CaseSensitive : Qt::CaseInsensitive;
#endif
        m_prefixMode =
            gCoreContext->GetBoolSetting("SortStripPrefixes", true)
            ? SortPrefixRemove : SortPrefixKeep;
        m_exclusions =
            gCoreContext->GetSetting("SortPrefixExceptions", "");
    }
    MythSortHelperCommon();
}
 
MythSortHelper::MythSortHelper(
    Qt::CaseSensitivity case_sensitive,
    SortPrefixMode prefix_mode,
    QString exclusions) :
    m_caseSensitive(case_sensitive),
    m_prefixMode(prefix_mode),
    m_exclusions(std::move(exclusions))
{
    MythSortHelperCommon();
}
 
MythSortHelper::MythSortHelper(MythSortHelper *other)
{
    if (other == nullptr)
    {
        LOG(VB_GENERAL, LOG_ERR,
            QString("MythSortHelper created from null pointer."));
        return;
    }
    m_caseSensitive   = other->m_caseSensitive;
    m_prefixMode      = other->m_prefixMode;
    m_prefixes        = other->m_prefixes;
    m_prefixesRegex   = other->m_prefixesRegex;
    m_prefixesRegex2  = other->m_prefixesRegex2;
    m_exclusions      = other->m_exclusions;
    m_exclList        = other->m_exclList;
    m_exclMode        = other->m_exclMode;
}
 
static std::shared_ptr<MythSortHelper> singleton = nullptr;
 
std::shared_ptr<MythSortHelper> getMythSortHelper(void)
{
    if (singleton == nullptr)
        singleton = std::make_shared<MythSortHelper>(new MythSortHelper());
    return singleton;
}
 
void resetMythSortHelper(void)
{
    singleton = nullptr;
}
 
QString MythSortHelper::doTitle(const QString& title) const
{
    QString ltitle = title;
    if (m_caseSensitive == Qt::CaseInsensitive)
        ltitle = ltitle.toLower();
    if (m_prefixMode == SortPrefixKeep)
        return ltitle;
    if (m_exclMode == SortExclusionMatch)
    {
        if (m_exclList.contains(ltitle))
            return ltitle;
    } else {
        for (const auto& str : qAsConst(m_exclList))
            if (ltitle.startsWith(str))
                return ltitle;
    }
    if (m_prefixMode == SortPrefixRemove)
        return ltitle.remove(m_prefixesRegex);
    return ltitle.replace(m_prefixesRegex2, "\\2, \\1").trimmed();
}
 
QString MythSortHelper::doPathname(const QString& pathname) const
{
    QString lpathname = pathname;
    if (m_caseSensitive == Qt::CaseInsensitive)
        lpathname = lpathname.toLower();
    if (m_prefixMode == SortPrefixKeep)
        return lpathname;
    QStringList parts = lpathname.split("/");
    for (int i = 0; i < parts.size(); ++i) {
        bool excluded = false;
        for (int j = 0; j < m_exclList.size(); ++j) {
            if (parts[i].startsWith(m_exclList[j])) {
                excluded = true;
                break;
            }
        }
        if (excluded)
            continue;
        if (m_prefixMode == SortPrefixRemove)
            parts[i] = parts[i].remove(m_prefixesRegex);
        else
            parts[i] = parts[i].replace(m_prefixesRegex2, "\\2, \\1").trimmed();
    }
    return parts.join("/");
}