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_prefix_mode = SortPrefixKeep;
        return;
    }
    if (not m_prefixes.startsWith("^"))
        m_prefixes = "^" + m_prefixes;

    if (m_case_sensitive == Qt::CaseInsensitive)
    {
        m_prefixes = m_prefixes.toLower();
        m_exclusions = m_exclusions.toLower();
    }
    m_prefixes_regex = QRegularExpression(m_prefixes);
    m_prefixes_regex2 = QRegularExpression(m_prefixes + "(.*)");
    m_excl_list = m_exclusions.split(";", QString::SkipEmptyParts);
    for (int i = 0; i < m_excl_list.size(); i++)
      m_excl_list[i] = m_excl_list[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_case_sensitive =
            gCoreContext->GetBoolSetting("SortCaseSensitive", false)
            ? Qt::CaseSensitive : Qt::CaseInsensitive;
#endif
        m_prefix_mode =
            gCoreContext->GetBoolSetting("SortStripPrefixes", true)
            ? SortPrefixRemove : SortPrefixKeep;
        m_exclusions =
            gCoreContext->GetSetting("SortPrefixExceptions", "");
    }
    MythSortHelperCommon();
}

MythSortHelper::MythSortHelper(
    Qt::CaseSensitivity case_sensitive,
    SortPrefixMode prefix_mode,
    QString exclusions) :
    m_case_sensitive(case_sensitive),
    m_prefix_mode(prefix_mode),
    m_exclusions(std::move(exclusions))
{
    MythSortHelperCommon();
}

MythSortHelper::MythSortHelper(MythSortHelper *other)
{
    m_case_sensitive  = other->m_case_sensitive;
    m_prefix_mode     = other->m_prefix_mode;
    m_prefixes        = other->m_prefixes;
    m_prefixes_regex  = other->m_prefixes_regex;
    m_prefixes_regex2 = other->m_prefixes_regex2;
    m_exclusions      = other->m_exclusions;
    m_excl_list       = other->m_excl_list;
    m_excl_mode       = other->m_excl_mode;
}

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_case_sensitive == Qt::CaseInsensitive)
        ltitle = ltitle.toLower();
    if (m_prefix_mode == SortPrefixKeep)
        return ltitle;
    if (m_excl_mode == SortExclusionMatch)
    {
        if (m_excl_list.contains(ltitle))
            return ltitle;
    } else {
        foreach (const QString &str, m_excl_list)
            if (ltitle.startsWith(str))
                return ltitle;
    }
    if (m_prefix_mode == SortPrefixRemove)
        return ltitle.remove(m_prefixes_regex);
    return ltitle.replace(m_prefixes_regex2, "\\2, \\1").trimmed();
}

QString MythSortHelper::doPathname(const QString& pathname) const
{
    QString lpathname = pathname;
    if (m_case_sensitive == Qt::CaseInsensitive)
        lpathname = lpathname.toLower();
    if (m_prefix_mode == SortPrefixKeep)
        return lpathname;
    QStringList parts = lpathname.split("/");
    for (int i = 0; i < parts.size(); ++i) {
        bool excluded = false;
        for (int j = 0; j < m_excl_list.size(); ++j) {
            if (parts[i].startsWith(m_excl_list[j])) {
                excluded = true;
                break;
            }
        }
        if (excluded)
            continue;
        if (m_prefix_mode == SortPrefixRemove)
            parts[i] = parts[i].remove(m_prefixes_regex);
        else
            parts[i] = parts[i].replace(m_prefixes_regex2, "\\2, \\1").trimmed();
    }
    return parts.join("/");
}