qcollator.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// Copyright (C) 2013 Aleix Pol Gonzalez <aleixpol@kde.org>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qcollator_p.h"
#include "qstringlist.h"
#include "qstring.h"
 
#include "qdebug.h"
#include "qlocale_p.h"
#include "qthreadstorage.h"
 
QT_BEGIN_NAMESPACE
 
namespace {
struct GenerationalCollator
{
    QCollator theCollator;
    int generation = QLocalePrivate::s_generation.loadRelaxed();
public:
    GenerationalCollator() = default;
    GenerationalCollator(const QCollator &copy) : theCollator(copy) {}
    QCollator &collator()
    {
        int currentGeneration = QLocalePrivate::s_generation.loadRelaxed();
        if (Q_UNLIKELY(generation != currentGeneration)) {
            // reinitialize the collator
            generation = currentGeneration;
            theCollator = QCollator();
        }
        return theCollator;
    }
};
}
Q_GLOBAL_STATIC(QThreadStorage<GenerationalCollator>, defaultCollator)
 
 
QCollator::QCollator()
    : d(new QCollatorPrivate(QLocale().collation()))
{
    d->init();
}
 
QCollator::QCollator(const QLocale &locale)
    : d(new QCollatorPrivate(locale))
{
}
 
QCollator::QCollator(const QCollator &other)
    : d(other.d)
{
    if (d) {
        // Ensure clean, lest both copies try to init() at the same time:
        d->ensureInitialized();
        d->ref.ref();
    }
}
 
QCollator::~QCollator()
{
    if (d && !d->ref.deref())
        delete d;
}
 
QCollator &QCollator::operator=(const QCollator &other)
{
    if (this != &other) {
        if (d && !d->ref.deref())
            delete d;
        d = other.d;
        if (d) {
            // Ensure clean, lest both copies try to init() at the same time:
            d->ensureInitialized();
            d->ref.ref();
        }
    }
    return *this;
}
 
void QCollator::detach()
{
    if (d->ref.loadRelaxed() != 1) {
        QCollatorPrivate *x = new QCollatorPrivate(d->locale);
        if (!d->ref.deref())
            delete d;
        d = x;
    }
    // All callers need this, because about to modify the object:
    d->dirty = true;
}
 
void QCollator::setLocale(const QLocale &locale)
{
    if (locale == d->locale)
        return;
 
    detach();
    d->locale = locale;
}
 
QLocale QCollator::locale() const
{
    return d->locale;
}
 
void QCollator::setCaseSensitivity(Qt::CaseSensitivity cs)
{
    if (d->caseSensitivity == cs)
        return;
 
    detach();
    d->caseSensitivity = cs;
}
 
Qt::CaseSensitivity QCollator::caseSensitivity() const
{
    return d->caseSensitivity;
}
 
void QCollator::setNumericMode(bool on)
{
    if (d->numericMode == on)
        return;
 
    detach();
    d->numericMode = on;
}
 
bool QCollator::numericMode() const
{
    return d->numericMode;
}
 
void QCollator::setIgnorePunctuation(bool on)
{
    if (d->ignorePunctuation == on)
        return;
 
    detach();
    d->ignorePunctuation = on;
}
 
bool QCollator::ignorePunctuation() const
{
    return d->ignorePunctuation;
}
 
int QCollator::defaultCompare(QStringView s1, QStringView s2)
{
    return defaultCollator->localData().collator().compare(s1, s2);
}
 
QCollatorSortKey QCollator::defaultSortKey(QStringView key)
{
    return defaultCollator->localData().collator().sortKey(key.toString());
}
 
QCollatorSortKey::QCollatorSortKey(QCollatorSortKeyPrivate *d)
    : d(d)
{
}
 
QCollatorSortKey::QCollatorSortKey(const QCollatorSortKey &other)
    : d(other.d)
{
}
 
QCollatorSortKey::~QCollatorSortKey()
{
}
 
QCollatorSortKey& QCollatorSortKey::operator=(const QCollatorSortKey &other)
{
    if (this != &other) {
        d = other.d;
    }
    return *this;
}
 
QT_END_NAMESPACE