Differential D8536 Diff 24381 src/widgets/kpropertiesdialog.cpp

Changeset View

Standalone View

View Options

src/widgets/kpropertiesdialog.cpp

Context not available.
54 54​
55#include <QCheckBox> 55​#include <QCheckBox>
56#include <QClipboard> 56​#include <QClipboard>
57​#include <QComboBox>
57#include <QDebug> 58​#include <QDebug>
58#include <QDBusConnection> 59​#include <QDBusConnection>
59#include <QDBusInterface> 60​#include <QDBusInterface>
Context not available.
70#include <QLocale> 71​#include <QLocale>
71#include <QMimeDatabase> 72​#include <QMimeDatabase>
72#include <QMutableStringListIterator> 73​#include <QMutableStringListIterator>
74​#include <QMutex>
73#include <QPainter> 75​#include <QPainter>
74#include <QProgressBar> 76​#include <QProgressBar>
75#include <QPushButton> 77​#include <QPushButton>
Context not available.
77#include <QStandardPaths> 79​#include <QStandardPaths>
78#include <QStyle> 80​#include <QStyle>
79#include <QtConcurrentRun> 81​#include <QtConcurrentRun>
82​#include <QtConcurrent/QtConcurrent>
80#include <QTextStream> 83​#include <QTextStream>
81#include <QUrl> 84​#include <QUrl>
82#include <QVector> 85​#include <QVector>
Context not available.
2633 emit leaveModality(); 2636​ emit leaveModality();
2634} 2637​}
2635 2638​
2639​/**
2640​ * List model for displaying `QCryptographicHash::Algorithm`s in a combobox
2641​ */
2642​class KChecksumAlgorithmListModel: public QAbstractListModel {
2643​ QVector<QCryptographicHash::Algorithm> algorithms;
2644​
2645​public:
2646​
2647​ KChecksumAlgorithmListModel(QObject *parent)
2648​ : QAbstractListModel(parent), algorithms({
2649​ QCryptographicHash::Md4,
2650​ QCryptographicHash::Md5,
2651​ QCryptographicHash::Sha1,
2652​ QCryptographicHash::Sha224,
2653​ QCryptographicHash::Sha256,
2654​ QCryptographicHash::Sha384,
2655​ QCryptographicHash::Sha512,
2656​ QCryptographicHash::Sha3_224,
2657​ QCryptographicHash::Sha3_256,
anthonyfieroniUnsubmitted
Done

Make it static const and initialize it here.

anthonyfieroni: Make it static const and initialize it here.
2658​ QCryptographicHash::Sha3_384,
2659​ QCryptographicHash::Sha3_512
2660​ }) {}
2661​
2662​ int rowCount(const QModelIndex &parent) const override {
2663​ return algorithms.size();
2664​ }
2665​
2666​ QVariant data(const QModelIndex &index, int role) const override {
2667​ if (!index.isValid())
2668​ return {};
2669​
2670​ if (index.row() >= algorithms.size() || index.row() < 0)
2671​ return {};
2672​
2673​ if (role == Qt::DisplayRole)
2674​ return QVariant::fromValue(algorithms.at(index.row()));
2675​
2676​ return {};
2677​ }
2678​};
2679​
2636class KChecksumsPlugin::KChecksumsPluginPrivate 2680​class KChecksumsPlugin::KChecksumsPluginPrivate
2637{ 2681​{
2638public: 2682​public:
anthonyfieroniUnsubmitted
Done

Use braces {} even on one line block in all places.

anthonyfieroni: Use braces {} even on one line block in all places.
Context not available.
2648 Ui::ChecksumsWidget m_ui; 2692​ Ui::ChecksumsWidget m_ui;
2649 2693​
2650 QFileSystemWatcher fileWatcher; 2694​ QFileSystemWatcher fileWatcher;
2651 QString m_md5; 2695​ QMap<QCryptographicHash::Algorithm, QString> cache;
2652 QString m_sha1; 2696​ mutable QMutex mutex;
2653 QString m_sha256; 2697​
2698​ KConfigGroup configGroup;
2654}; 2699​};
2655 2700​
2656KChecksumsPlugin::KChecksumsPlugin(KPropertiesDialog *dialog) 2701​KChecksumsPlugin::KChecksumsPlugin(KPropertiesDialog *dialog)
2657 : KPropertiesDialogPlugin(dialog), d(new KChecksumsPluginPrivate) 2702​ : KPropertiesDialogPlugin(dialog), d(new KChecksumsPluginPrivate)
2658{ 2703​{
2659 d->m_ui.setupUi(&d->m_widget); 2704​ d->m_ui.setupUi(&d->m_widget);
2660 properties->addPage(&d->m_widget, i18nc("@title:tab", "C&hecksums")); 2705​ properties->addPage(&d->m_widget, i18nc("@title:tab", "Checksums"));
2706​
2707​ d->configGroup = KConfigGroup(KSharedConfig::openConfig(), "KPropertiesDialog");
2661 2708​
2662 d->m_ui.md5CopyButton->hide(); 2709​ d->m_ui.algorithmComboBox->setModel(new KChecksumAlgorithmListModel(this));
2663 d->m_ui.sha1CopyButton->hide(); 2710​
2664 d->m_ui.sha256CopyButton->hide(); 2711​ setAlgorithm(readDefaultAlgorithm());
2712​
2713​ connect(d->m_ui.algorithmComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, [=](int) {
2714​ writeDefaultAlgorithm(algorithm());
2715​ });
2665 2716​
2666 connect(d->m_ui.lineEdit, &QLineEdit::textChanged, this, [=](const QString &text) { 2717​ connect(d->m_ui.lineEdit, &QLineEdit::textChanged, this, [=](const QString &text) {
2667 slotVerifyChecksum(text.toLower()); 2718​ slotVerifyChecksum(text.toLower());
2668 }); 2719​ });
2669 2720​
2670 connect(d->m_ui.md5Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowMd5); ​
2671 connect(d->m_ui.sha1Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowSha1); ​
2672 connect(d->m_ui.sha256Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowSha256); ​
2673 ​
2674 d->fileWatcher.addPath(properties->item().localPath()); 2721​ d->fileWatcher.addPath(properties->item().localPath());
2675 connect(&d->fileWatcher, &QFileSystemWatcher::fileChanged, this, &KChecksumsPlugin::slotInvalidateCache); 2722​ connect(&d->fileWatcher, &QFileSystemWatcher::fileChanged, this, &KChecksumsPlugin::slotInvalidateCache);
2676 2723​
2677 auto clipboard = QApplication::clipboard(); 2724​ connect(d->m_ui.calculateButton, &QPushButton::clicked, this, [=]() {
2678 connect(d->m_ui.md5CopyButton, &QPushButton::clicked, this, [=]() { 2725​ showChecksum(algorithm());
2679 clipboard->setText(d->m_md5); ​
2680 }); 2726​ });
2681 2727​
2682 connect(d->m_ui.sha1CopyButton, &QPushButton::clicked, this, [=]() { 2728​ auto clipboard = QApplication::clipboard();
2683 clipboard->setText(d->m_sha1); ​
2684 }); ​
2685 2729​
2686 connect(d->m_ui.sha256CopyButton, &QPushButton::clicked, this, [=]() { 2730​ d->m_ui.copyButton->hide();
2687 clipboard->setText(d->m_sha256); 2731​ connect(d->m_ui.copyButton, &QPushButton::clicked, this, [=]() {
2732​ clipboard->setText(d->m_ui.valueLabel->text());
2688 }); 2733​ });
2689 2734​
2690 connect(d->m_ui.pasteButton, &QPushButton::clicked, this, [=]() { 2735​ connect(d->m_ui.pasteButton, &QPushButton::clicked, this, [=]() {
Context not available.
2705 return false; 2750​ return false;
2706 } 2751​ }
2707 2752​
2708 const KFileItem item = items.first(); 2753​ const auto& item = items.first();
2709 return item.isFile() && item.isLocalFile() && item.isReadable() && !item.isDesktopFile() && !item.isLink(); 2754​ return item.isFile() && item.isLocalFile() && item.isReadable() && !item.isDesktopFile() && !item.isLink();
2710} 2755​}
2711 2756​
2712void KChecksumsPlugin::slotInvalidateCache() 2757​void KChecksumsPlugin::slotInvalidateCache()
anthonyfieroniUnsubmitted
Done

1 space between ) { in all places

anthonyfieroni: 1 space between ) { in all places
2713{ 2758​{
2714 d->m_md5 = QString(); 2759​ d->cache.clear();
2715 d->m_sha1 = QString(); ​
2716 d->m_sha256 = QString(); ​
2717} 2760​}
2718 2761​
2719void KChecksumsPlugin::slotShowMd5() 2762​void KChecksumsPlugin::verifyChecksums(const QString input, QVector<QCryptographicHash::Algorithm> algorithms)
2720{ 2763​{
2721 auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget); 2764​ if (algorithms.isEmpty()) {
2722 label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard); 2765​ return;
2766​ }
2723 2767​
2724 d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.md5Button, label); 2768​ auto futureWatcher = new QFutureWatcher<bool>(this);
2725 d->m_ui.md5Button->hide(); ​
2726 2769​
2727 showChecksum(QCryptographicHash::Md5, label, d->m_ui.md5CopyButton); 2770​ connect(futureWatcher, &QFutureWatcher<bool>::finished, this, [=]() {
2728} 2771​ const bool match = futureWatcher->result();
2772​ futureWatcher->deleteLater();
2729 2773​
2730void KChecksumsPlugin::slotShowSha1() 2774​ if (match) {
2731{ 2775​ showMatchedChecksum();
2732 auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget); 2776​ setMatchState();
2733 label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard); 2777​ } else {
2778​ setMismatchState();
2779​ }
2780​ });
2734 2781​
2735 d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha1Button, label); 2782​ std::function<QString(QCryptographicHash::Algorithm)> mapper = [this](QCryptographicHash::Algorithm alg) {
anthonyfieroniUnsubmitted
Done

Are you sure about calling this function in all watchers?

anthonyfieroni: Are you sure about calling this function in all watchers?
2736 d->m_ui.sha1Button->hide(); 2783​ const QString cache = cachedChecksum(alg);
2784​ if (!cache.isEmpty()) {
2785​ return cache;
2786​ }
2737 2787​
2738 showChecksum(QCryptographicHash::Sha1, label, d->m_ui.sha1CopyButton); 2788​ const QString checksum = computeChecksum(alg, properties->item().localPath());
2739} 2789​ cacheChecksum(checksum, alg);
2740 2790​
2741void KChecksumsPlugin::slotShowSha256() 2791​ return checksum;
2742{ 2792​ };
2743 auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget); 2793​
2744 label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard); 2794​ std::function<void(bool&, const QString&)> reducer = [input](bool& match, const QString& checksum) {
anthonyfieroniUnsubmitted
Done

Why not create all watchers in a loop not in recursion. When you use non-const QVector it can't garanteed that it'll not make a deep copy.

verifyChecksumRecursive(input, std::move(algorithms));

?

anthonyfieroni: Why not create all watchers in a loop not in recursion. When you use non-const QVector it can't…
2795​ match |= checksum == input;
anthonyfieroniUnsubmitted
Not Done

You don't understand me, now you have a race condition. cachedChecksum reads from cache while cacheChecksum writes. It's a race condition and you need mutex here. When you add here you will not needed anymore in cacheChecksum.

anthonyfieroni: You don't understand me, now you have a race condition. cachedChecksum reads from cache while…
petermajchrakAuthorUnsubmitted
Not Done

But adding a mutex for guarding the body of the mapper function will serialize the hash computations. The computations themselves are independent and parallelizable, only the synchronization points (cachedChecksum and cacheChecksum) are not.

petermajchrak: But adding a mutex for guarding the body of the mapper function will serialize the hash…
anthonyfieroniUnsubmitted
Not Done

I understand but you don't have a choice, now this *works* on luck you can face a crash when one thread read caches while one writes it.

anthonyfieroni: I understand but you don't have a choice, now this *works* on luck you can face a crash when…
petermajchrakAuthorUnsubmitted
Not Done

I can add two critical sections, one for reading the cache and one for writing while the hash computation is not in either of them

petermajchrak: I can add two critical sections, one for reading the cache and one for writing while the hash…
anthonyfieroniUnsubmitted
Not Done

Basically you need computation only one time when you don't have cache so you can check if cache does not exist then make a future watcher. In this case you can use blockedMappedReduced to wait all threads and mapper function looks like

std::function<QString(QCryptographicHash::Algorithm)> mapper = [this, path](QCryptographicHash::Algorithm alg) {
    const QString checksum = computeChecksum(alg, path);
     QMutexLocker locker(&d->mutex);
     cacheChecksum(checksum, alg);
}
anthonyfieroni: Basically you need computation only one time when you don't have cache so you can check if…
2796​ };
2745 2797​
anthonyfieroniUnsubmitted
Done

Better get localPath before concurrent function and you should use mutex as well, simultaneously read/write is data race i.e.

const auto itemPath = properties->item().localPath();
std::function<QString(QCryptographicHash::Algorithm)> mapper = [itemPath, this](QCryptographicHash::Algorithm alg) {
    QMutexLocker locker(&d->mutex);
anthonyfieroni: Better get localPath before concurrent function and you should use mutex as well…
2746 d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha256Button, label); 2798​ QFuture<bool> future = QtConcurrent::mappedReduced<bool>(algorithms, mapper, reducer);
2747 d->m_ui.sha256Button->hide(); ​
2748 2799​
2749 showChecksum(QCryptographicHash::Sha256, label, d->m_ui.sha256CopyButton); 2800​ futureWatcher->setFuture(future);
2750} 2801​}
2751 2802​
2752void KChecksumsPlugin::slotVerifyChecksum(const QString &input) 2803​void KChecksumsPlugin::slotVerifyChecksum(const QString &input)
2753{ 2804​{
2754 auto algorithm = detectAlgorithm(input); 2805​ auto algorithms = detectAlgorithms(input);
2755 2806​
2756 // Input is not a supported hash algorithm. 2807​ // Input is not a supported hash algorithm.
2757 if (algorithm == QCryptographicHash::Md4) { 2808​ if (algorithms.isEmpty()) {
2758 if (input.isEmpty()) { 2809​ if (input.isEmpty()) {
2759 setDefaultState(); 2810​ setDefaultState();
2760 } else { 2811​ } else {
Context not available.
2763 return; 2814​ return;
2764 } 2815​ }
2765 2816​
2766 const QString checksum = cachedChecksum(algorithm); ​
2767 ​
2768 // Checksum alread in cache. ​
2769 if (!checksum.isEmpty()) { ​
2770 const bool isMatch = (checksum == input); ​
2771 if (isMatch) { ​
2772 setMatchState(); ​
2773 } else { ​
2774 setMismatchState(); ​
2775 } ​
2776 ​
2777 return; ​
2778 } ​
2779 ​
2780 // Calculate checksum in another thread. ​
2781 auto futureWatcher = new QFutureWatcher<QString>(this); ​
2782 connect(futureWatcher, &QFutureWatcher<QString>::finished, this, [=]() { ​
2783 ​
2784 const QString checksum = futureWatcher->result(); ​
2785 futureWatcher->deleteLater(); ​
2786 ​
2787 cacheChecksum(checksum, algorithm); ​
2788 ​
2789 switch (algorithm) { ​
2790 case QCryptographicHash::Md5: ​
2791 slotShowMd5(); ​
2792 break; ​
2793 case QCryptographicHash::Sha1: ​
2794 slotShowSha1(); ​
2795 break; ​
2796 case QCryptographicHash::Sha256: ​
2797 slotShowSha256(); ​
2798 break; ​
2799 default: ​
2800 break; ​
2801 } ​
2802 ​
2803 const bool isMatch = (checksum == input); ​
2804 if (isMatch) { ​
2805 setMatchState(); ​
2806 } else { ​
2807 setMismatchState(); ​
2808 } ​
2809 }); ​
2810 ​
2811 // Notify the user about the background computation. 2817​ // Notify the user about the background computation.
2812 setVerifyState(); 2818​ setVerifyState();
2813 2819​
2814 auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath()); 2820​ verifyChecksums(input, algorithms);
2815 futureWatcher->setFuture(future); ​
2816} ​
2817 ​
2818bool KChecksumsPlugin::isMd5(const QString &input) ​
2819{ ​
2820 QRegularExpression regex(QStringLiteral("^[a-f0-9]{32}$")); ​
2821 return regex.match(input).hasMatch(); ​
2822} ​
2823 ​
2824bool KChecksumsPlugin::isSha1(const QString &input) ​
2825{ ​
2826 QRegularExpression regex(QStringLiteral("^[a-f0-9]{40}$")); ​
2827 return regex.match(input).hasMatch(); ​
2828} ​
2829 ​
2830bool KChecksumsPlugin::isSha256(const QString &input) ​
2831{ ​
2832 QRegularExpression regex(QStringLiteral("^[a-f0-9]{64}$")); ​
2833 return regex.match(input).hasMatch(); ​
2834} 2821​}
2835 2822​
2836QString KChecksumsPlugin::computeChecksum(QCryptographicHash::Algorithm algorithm, const QString &path) 2823​QString KChecksumsPlugin::computeChecksum(QCryptographicHash::Algorithm algorithm, const QString &path)
petermajchrakAuthorUnsubmitted
Not Done

If the mutex is locked only around the cacheChecksum function I might as well put in back inside it

petermajchrak: If the mutex is locked only around the cacheChecksum function I might as well put in back…
Context not available.
2846 return QString::fromLatin1(hash.result().toHex()); 2833​ return QString::fromLatin1(hash.result().toHex());
2847} 2834​}
2848 2835​
2849QCryptographicHash::Algorithm KChecksumsPlugin::detectAlgorithm(const QString &input) 2836​QVector<QCryptographicHash::Algorithm> KChecksumsPlugin::detectAlgorithms(const QString &input)
2850{ 2837​{
2851 if (isMd5(input)) { 2838​ static const QVector<QPair<QCryptographicHash::Algorithm, QRegularExpression>> regexes{
2852 return QCryptographicHash::Md5; 2839​ {QCryptographicHash::Md4, QRegularExpression("^[a-f0-9]{32}$")},
2853 } 2840​ {QCryptographicHash::Md5, QRegularExpression("^[a-f0-9]{32}$")},
2841​ {QCryptographicHash::Sha1, QRegularExpression("^[a-f0-9]{40}$")},
2842​ {QCryptographicHash::Sha224, QRegularExpression("^[a-f0-9]{56}$")},
2843​ {QCryptographicHash::Sha256, QRegularExpression("^[a-f0-9]{64}$")},
2844​ {QCryptographicHash::Sha384, QRegularExpression("^[a-f0-9]{96}$")},
2845​ {QCryptographicHash::Sha512, QRegularExpression("^[a-f0-9]{128}$")},
2846​ {QCryptographicHash::Sha3_224, QRegularExpression("^[a-f0-9]{56}$")},
2847​ {QCryptographicHash::Sha3_256, QRegularExpression("^[a-f0-9]{64}$")},
2848​ {QCryptographicHash::Sha3_384, QRegularExpression("^[a-f0-9]{96}$")},
2849​ {QCryptographicHash::Sha3_512, QRegularExpression("^[a-f0-9]{128}$")}
2850​ };
2854 2851​
2855 if (isSha1(input)) { 2852​ QVector<QCryptographicHash::Algorithm> algorithms;
2856 return QCryptographicHash::Sha1; ​
2857 } ​
2858 2853​
2859 if (isSha256(input)) { 2854​ for (const auto &p : regexes) {
2860 return QCryptographicHash::Sha256; 2855​ if (p.second.match(input).hasMatch()) {
2856​ algorithms.push_back(p.first);
2857​ }
2861 } 2858​ }
2862 2859​
2863 // Md4 used as negative error code. 2860​ return algorithms;
2864 return QCryptographicHash::Md4; ​
2865} 2861​}
2866 2862​
2867void KChecksumsPlugin::setDefaultState() 2863​void KChecksumsPlugin::setDefaultState()
anthonyfieroniUnsubmitted
Done

It's a private function, i can't image why it can be call with null pointers :)

anthonyfieroni: It's a private function, i can't image why it can be call with null pointers :)
petermajchrakAuthorUnsubmitted
Done

I am looking up the UI components based on name and I was getting some nullptrs until I found the right way to get them correctly from the layout. Not sure if they are needed but in case something in the layout changes (like a name of a button) it might pass in a nullptr

petermajchrak: I am looking up the UI components based on name and I was getting some nullptrs until I found…
Context not available.
2929 d->m_ui.feedbackLabel->show(); 2925​ d->m_ui.feedbackLabel->show();
2930} 2926​}
2931 2927​
2932void KChecksumsPlugin::showChecksum(QCryptographicHash::Algorithm algorithm, QLabel *label, QPushButton *copyButton) 2928​void KChecksumsPlugin::showMatchedChecksum()
2933{ 2929​{
2930​ for (const auto alg : d->cache.keys()) {
2931​ if(d->m_ui.lineEdit->text() == d->cache.value(alg, "")) {
2932​ showChecksum(alg);
2933​ return;
2934​ }
2935​ }
2936​}
2937​
2938​void KChecksumsPlugin::showChecksum(QCryptographicHash::Algorithm algorithm)
2939​{
2940​ setAlgorithm(algorithm);
2941​
2942​ auto label = d->m_ui.valueLabel;
2943​ label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
2944​
2934 const QString checksum = cachedChecksum(algorithm); 2945​ const QString checksum = cachedChecksum(algorithm);
2935 2946​
2936 // Checksum in cache, nothing else to do. 2947​ // Checksum in cache, nothing else to do.
Context not available.
2948 label->setText(checksum); 2959​ label->setText(checksum);
2949 cacheChecksum(checksum, algorithm); 2960​ cacheChecksum(checksum, algorithm);
2950 2961​
2951 copyButton->show(); 2962​ d->m_ui.copyButton->show();
2952 }); 2963​ });
2953 2964​
2954 auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath()); 2965​ auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath());
2955 futureWatcher->setFuture(future); 2966​ futureWatcher->setFuture(future);
2956} 2967​}
2957 2968​
2958QString KChecksumsPlugin::cachedChecksum(QCryptographicHash::Algorithm algorithm) const 2969​void KChecksumsPlugin::writeDefaultAlgorithm(QCryptographicHash::Algorithm algorithm)
2959{ 2970​{
2960 switch (algorithm) { 2971​ d->configGroup.writeEntry("algorithm", static_cast<int>(algorithm));
2961 case QCryptographicHash::Md5: 2972​}
2962 return d->m_md5; 2973​
2963 case QCryptographicHash::Sha1: 2974​QCryptographicHash::Algorithm KChecksumsPlugin::readDefaultAlgorithm() const
2964 return d->m_sha1; 2975​{
2965 case QCryptographicHash::Sha256: 2976​ return static_cast<QCryptographicHash::Algorithm>(d->configGroup.readEntry("algorithm", static_cast<int>(QCryptographicHash::Sha256)));
2966 return d->m_sha256; 2977​}
2967 default: 2978​
2968 break; 2979​void KChecksumsPlugin::setAlgorithm(QCryptographicHash::Algorithm algorithm)
2969 } 2980​{
2981​ int index = d->m_ui.algorithmComboBox->findData(QVariant::fromValue(algorithm), Qt::DisplayRole);
2982​ d->m_ui.algorithmComboBox->setCurrentIndex(index);
2983​}
2984​
2985​QCryptographicHash::Algorithm KChecksumsPlugin::algorithm() const
2986​{
2987​ return d->m_ui.algorithmComboBox->currentData(Qt::DisplayRole).value<QCryptographicHash::Algorithm>();
2988​}
2970 2989​
2971 return QString(); 2990​QString KChecksumsPlugin::cachedChecksum(QCryptographicHash::Algorithm algorithm) const
2991​{
2992​ return d->cache.value(algorithm, QString{});
2972} 2993​}
2973 2994​
2974void KChecksumsPlugin::cacheChecksum(const QString &checksum, QCryptographicHash::Algorithm algorithm) 2995​void KChecksumsPlugin::cacheChecksum(const QString &checksum, QCryptographicHash::Algorithm algorithm)
2975{ 2996​{
2976 switch (algorithm) { 2997​ QMutexLocker locker(&d->mutex);
2977 case QCryptographicHash::Md5: 2998​ d->cache.insert(algorithm, checksum);
anthonyfieroniUnsubmitted
Done

Mutex is not needed here.

anthonyfieroni: Mutex is not needed here.
petermajchrakAuthorUnsubmitted
Done

This function is called from the QtConcurrent mapper function and therefore can be called concurrently by more threads. QMap::insert is not thread safe for concurrent write operations as far as I know.

petermajchrak: This function is called from the QtConcurrent mapper function and therefore can be called…
2978 d->m_md5 = checksum; ​
2979 break; ​
2980 case QCryptographicHash::Sha1: ​
2981 d->m_sha1 = checksum; ​
2982 break; ​
2983 case QCryptographicHash::Sha256: ​
2984 d->m_sha256 = checksum; ​
2985 break; ​
2986 default: ​
2987 return; ​
2988 } ​
2989} 2999​}
2990 3000​
2991class KUrlPropsPlugin::KUrlPropsPluginPrivate 3001​class KUrlPropsPlugin::KUrlPropsPluginPrivate
Context not available.