Differential D8536 Diff 24402 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​ QCryptographicHash::Algorithm at(int index) const {
2667​ return algorithms.at(index);
2668​ }
2669​
2670​ int find(QCryptographicHash::Algorithm alg) const {
2671​ return algorithms.indexOf(alg);
2672​ }
2673​
2674​ QVariant data(const QModelIndex &index, int role) const override {
2675​ if (!index.isValid())
2676​ return {};
2677​
2678​ if (index.row() >= algorithms.size() || index.row() < 0)
2679​ return {};
2680​
2681​ if (role == Qt::DisplayRole) {
2682​ const auto alg = algorithms.at(index.row());
anthonyfieroniUnsubmitted
Done

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

anthonyfieroni: Use braces {} even on one line block in all places.
2683​ const auto v = QVariant::fromValue(alg);
2684​ return QVariant::fromValue(
2685​ v.toString().replace("Real", "").replace('_', '-').toUpper()
2686​ );
2687​ }
2688​
2689​ return {};
2690​ }
2691​};
2692​
2636class KChecksumsPlugin::KChecksumsPluginPrivate 2693​class KChecksumsPlugin::KChecksumsPluginPrivate
2637{ 2694​{
2638public: 2695​public:
Context not available.
2648 Ui::ChecksumsWidget m_ui; 2705​ Ui::ChecksumsWidget m_ui;
2649 2706​
2650 QFileSystemWatcher fileWatcher; 2707​ QFileSystemWatcher fileWatcher;
2651 QString m_md5; 2708​ QMap<QCryptographicHash::Algorithm, QString> cache;
2652 QString m_sha1; 2709​ mutable QMutex mutex;
2653 QString m_sha256; 2710​
2711​ KConfigGroup configGroup;
2654}; 2712​};
2655 2713​
2656KChecksumsPlugin::KChecksumsPlugin(KPropertiesDialog *dialog) 2714​KChecksumsPlugin::KChecksumsPlugin(KPropertiesDialog *dialog)
2657 : KPropertiesDialogPlugin(dialog), d(new KChecksumsPluginPrivate) 2715​ : KPropertiesDialogPlugin(dialog), d(new KChecksumsPluginPrivate)
2658{ 2716​{
2659 d->m_ui.setupUi(&d->m_widget); 2717​ d->m_ui.setupUi(&d->m_widget);
2660 properties->addPage(&d->m_widget, i18nc("@title:tab", "C&hecksums")); 2718​ properties->addPage(&d->m_widget, i18nc("@title:tab", "Checksums"));
2719​
2720​ d->configGroup = KConfigGroup(KSharedConfig::openConfig(), "KPropertiesDialog");
2661 2721​
2662 d->m_ui.md5CopyButton->hide(); 2722​ d->m_ui.algorithmComboBox->setModel(new KChecksumAlgorithmListModel(this));
2663 d->m_ui.sha1CopyButton->hide(); 2723​
2664 d->m_ui.sha256CopyButton->hide(); 2724​ setAlgorithm(readDefaultAlgorithm());
2725​
2726​ connect(d->m_ui.algorithmComboBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, [=](int) {
2727​ const auto alg = algorithm();
2728​ d->m_ui.valueLabel->setText(cachedChecksum(alg));
2729​ writeDefaultAlgorithm(alg);
2730​ });
2665 2731​
2666 connect(d->m_ui.lineEdit, &QLineEdit::textChanged, this, [=](const QString &text) { 2732​ connect(d->m_ui.lineEdit, &QLineEdit::textChanged, this, [=](const QString &text) {
2667 slotVerifyChecksum(text.toLower()); 2733​ slotVerifyChecksum(text.toLower());
2668 }); 2734​ });
2669 2735​
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()); 2736​ d->fileWatcher.addPath(properties->item().localPath());
2675 connect(&d->fileWatcher, &QFileSystemWatcher::fileChanged, this, &KChecksumsPlugin::slotInvalidateCache); 2737​ connect(&d->fileWatcher, &QFileSystemWatcher::fileChanged, this, &KChecksumsPlugin::slotInvalidateCache);
2676 2738​
2677 auto clipboard = QApplication::clipboard(); 2739​ connect(d->m_ui.calculateButton, &QPushButton::clicked, this, [=]() {
2678 connect(d->m_ui.md5CopyButton, &QPushButton::clicked, this, [=]() { 2740​ showChecksum(algorithm());
2679 clipboard->setText(d->m_md5); ​
2680 }); 2741​ });
2681 2742​
2682 connect(d->m_ui.sha1CopyButton, &QPushButton::clicked, this, [=]() { 2743​ auto clipboard = QApplication::clipboard();
2683 clipboard->setText(d->m_sha1); ​
2684 }); ​
2685 2744​
2686 connect(d->m_ui.sha256CopyButton, &QPushButton::clicked, this, [=]() { 2745​ d->m_ui.copyButton->hide();
2687 clipboard->setText(d->m_sha256); 2746​ connect(d->m_ui.copyButton, &QPushButton::clicked, this, [=]() {
2747​ clipboard->setText(d->m_ui.valueLabel->text());
2688 }); 2748​ });
2689 2749​
2690 connect(d->m_ui.pasteButton, &QPushButton::clicked, this, [=]() { 2750​ connect(d->m_ui.pasteButton, &QPushButton::clicked, this, [=]() {
anthonyfieroniUnsubmitted
Done

1 space between ) { in all places

anthonyfieroni: 1 space between ) { in all places
Context not available.
2705 return false; 2765​ return false;
2706 } 2766​ }
2707 2767​
2708 const KFileItem item = items.first(); 2768​ const auto& item = items.first();
2709 return item.isFile() && item.isLocalFile() && item.isReadable() && !item.isDesktopFile() && !item.isLink(); 2769​ return item.isFile() && item.isLocalFile() && item.isReadable() && !item.isDesktopFile() && !item.isLink();
2710} 2770​}
2711 2771​
2712void KChecksumsPlugin::slotInvalidateCache() 2772​void KChecksumsPlugin::slotInvalidateCache()
2713{ 2773​{
2714 d->m_md5 = QString(); 2774​ d->cache.clear();
2715 d->m_sha1 = QString(); ​
2716 d->m_sha256 = QString(); ​
2717} ​
2718 ​
2719void KChecksumsPlugin::slotShowMd5() ​
2720{ ​
2721 auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget); ​
2722 label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard); ​
2723 ​
2724 d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.md5Button, label); ​
2725 d->m_ui.md5Button->hide(); ​
2726 ​
2727 showChecksum(QCryptographicHash::Md5, label, d->m_ui.md5CopyButton); ​
2728} ​
2729 ​
2730void KChecksumsPlugin::slotShowSha1() ​
2731{ ​
2732 auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget); ​
2733 label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard); ​
2734 ​
2735 d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha1Button, label); ​
2736 d->m_ui.sha1Button->hide(); ​
2737 ​
2738 showChecksum(QCryptographicHash::Sha1, label, d->m_ui.sha1CopyButton); ​
2739} ​
2740 ​
2741void KChecksumsPlugin::slotShowSha256() ​
2742{ ​
2743 auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget); ​
2744 label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard); ​
2745 ​
2746 d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha256Button, label); ​
2747 d->m_ui.sha256Button->hide(); ​
2748 ​
2749 showChecksum(QCryptographicHash::Sha256, label, d->m_ui.sha256CopyButton); ​
2750} 2775​}
2751 2776​
2752void KChecksumsPlugin::slotVerifyChecksum(const QString &input) 2777​void KChecksumsPlugin::verifyChecksums(const QString input, QVector<QCryptographicHash::Algorithm> algorithms)
2753{ 2778​{
2754 auto algorithm = detectAlgorithm(input); 2779​ if (algorithms.isEmpty()) {
2755 ​
2756 // Input is not a supported hash algorithm. ​
2757 if (algorithm == QCryptographicHash::Md4) { ​
2758 if (input.isEmpty()) { ​
2759 setDefaultState(); ​
2760 } else { ​
2761 setInvalidChecksumState(); ​
2762 } ​
2763 return; 2780​ return;
2764 } 2781​ }
2765 2782​
anthonyfieroniUnsubmitted
Done

Are you sure about calling this function in all watchers?

anthonyfieroni: Are you sure about calling this function in all watchers?
2766 const QString checksum = cachedChecksum(algorithm); 2783​ // check cache
2767 2784​ bool foundInCache = false;
2768 // Checksum alread in cache. 2785​ QVector<QCryptographicHash::Algorithm> algorithmsToCompute;
2769 if (!checksum.isEmpty()) { 2786​ for (const auto alg : algorithms) {
2770 const bool isMatch = (checksum == input); 2787​ const auto cache = cachedChecksum(alg);
2771 if (isMatch) { 2788​ if (!cache.isEmpty()) {
2772 setMatchState(); 2789​ if (cache == input) {
2790​ foundInCache = true;
2791​ break;
2792​ }
2773 } else { 2793​ } else {
2774 setMismatchState(); 2794​ algorithmsToCompute.push_back(alg);
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…
2775 } 2795​ }
2796​ }
2776 2797​
2798​ if (foundInCache) {
2799​ showMatchedChecksum();
2800​ setMatchState();
2777 return; 2801​ return;
2778 } 2802​ }
2779 2803​
2780 // Calculate checksum in another thread. 2804​ auto futureWatcher = new QFutureWatcher<bool>(this);
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…
2781 auto futureWatcher = new QFutureWatcher<QString>(this); ​
2782 connect(futureWatcher, &QFutureWatcher<QString>::finished, this, [=]() { ​
2783 2805​
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…
2784 const QString checksum = futureWatcher->result(); 2806​ connect(futureWatcher, &QFutureWatcher<bool>::finished, this, [=]() {
2807​ const bool match = futureWatcher->result();
2785 futureWatcher->deleteLater(); 2808​ futureWatcher->deleteLater();
2786 2809​
2787 cacheChecksum(checksum, algorithm); 2810​ if (match) {
2788 2811​ showMatchedChecksum();
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(); 2812​ setMatchState();
2806 } else { 2813​ } else {
2807 setMismatchState(); 2814​ setMismatchState();
2808 } 2815​ }
2809 }); 2816​ });
2810 2817​
2811 // Notify the user about the background computation. 2818​ const auto path = properties->item().localPath();
2812 setVerifyState(); 2819​
2820​ std::function<QString(QCryptographicHash::Algorithm)> mapper = [this, path](QCryptographicHash::Algorithm alg) {
2821​ const QString checksum = computeChecksum(alg, path);
2822​ {
2823​ // Concurrent cache write
2824​ QMutexLocker locker(&d->mutex);
2825​ cacheChecksum(checksum, alg);
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…
2826​ }
2827​ return checksum;
2828​ };
2829​
2830​ std::function<void(bool&, const QString&)> reducer = [input](bool& match, const QString& checksum) {
2831​ match |= checksum == input;
2832​ };
2833​
2834​ QFuture<bool> future = QtConcurrent::mappedReduced<bool>(algorithmsToCompute, mapper, reducer);
2813 2835​
2814 auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath()); ​
2815 futureWatcher->setFuture(future); 2836​ futureWatcher->setFuture(future);
2816} 2837​}
2817 2838​
2818bool KChecksumsPlugin::isMd5(const QString &input) 2839​void KChecksumsPlugin::slotVerifyChecksum(const QString &input)
2819{ 2840​{
2820 QRegularExpression regex(QStringLiteral("^[a-f0-9]{32}$")); 2841​ auto algorithms = detectAlgorithms(input);
2821 return regex.match(input).hasMatch(); ​
2822} ​
2823 2842​
2824bool KChecksumsPlugin::isSha1(const QString &input) 2843​ // Input is not a supported hash algorithm.
2825{ 2844​ if (algorithms.isEmpty()) {
2826 QRegularExpression regex(QStringLiteral("^[a-f0-9]{40}$")); 2845​ if (input.isEmpty()) {
2827 return regex.match(input).hasMatch(); 2846​ setDefaultState();
2828} 2847​ } else {
2848​ setInvalidChecksumState();
2849​ }
2850​ return;
2851​ }
2829 2852​
2830bool KChecksumsPlugin::isSha256(const QString &input) 2853​ // Notify the user about the background computation.
2831{ 2854​ setVerifyState();
2832 QRegularExpression regex(QStringLiteral("^[a-f0-9]{64}$")); 2855​
2833 return regex.match(input).hasMatch(); 2856​ verifyChecksums(input, algorithms);
2834} 2857​}
2835 2858​
2836QString KChecksumsPlugin::computeChecksum(QCryptographicHash::Algorithm algorithm, const QString &path) 2859​QString KChecksumsPlugin::computeChecksum(QCryptographicHash::Algorithm algorithm, const QString &path)
Context not available.
2846 return QString::fromLatin1(hash.result().toHex()); 2869​ return QString::fromLatin1(hash.result().toHex());
2847} 2870​}
2848 2871​
2849QCryptographicHash::Algorithm KChecksumsPlugin::detectAlgorithm(const QString &input) 2872​QVector<QCryptographicHash::Algorithm> KChecksumsPlugin::detectAlgorithms(const QString &input)
2850{ 2873​{
2851 if (isMd5(input)) { 2874​ static const QVector<QPair<QCryptographicHash::Algorithm, QRegularExpression>> regexes{
2852 return QCryptographicHash::Md5; 2875​ {QCryptographicHash::Md4, QRegularExpression("^[a-f0-9]{32}$")},
2853 } 2876​ {QCryptographicHash::Md5, QRegularExpression("^[a-f0-9]{32}$")},
2877​ {QCryptographicHash::Sha1, QRegularExpression("^[a-f0-9]{40}$")},
2878​ {QCryptographicHash::Sha224, QRegularExpression("^[a-f0-9]{56}$")},
2879​ {QCryptographicHash::Sha256, QRegularExpression("^[a-f0-9]{64}$")},
2880​ {QCryptographicHash::Sha384, QRegularExpression("^[a-f0-9]{96}$")},
2881​ {QCryptographicHash::Sha512, QRegularExpression("^[a-f0-9]{128}$")},
2882​ {QCryptographicHash::Sha3_224, QRegularExpression("^[a-f0-9]{56}$")},
2883​ {QCryptographicHash::Sha3_256, QRegularExpression("^[a-f0-9]{64}$")},
2884​ {QCryptographicHash::Sha3_384, QRegularExpression("^[a-f0-9]{96}$")},
2885​ {QCryptographicHash::Sha3_512, QRegularExpression("^[a-f0-9]{128}$")}
2886​ };
2854 2887​
2855 if (isSha1(input)) { 2888​ QVector<QCryptographicHash::Algorithm> algorithms;
2856 return QCryptographicHash::Sha1; ​
2857 } ​
2858 2889​
2859 if (isSha256(input)) { 2890​ for (const auto &p : regexes) {
2860 return QCryptographicHash::Sha256; 2891​ if (p.second.match(input).hasMatch()) {
2892​ algorithms.push_back(p.first);
2893​ }
2861 } 2894​ }
2862 2895​
2863 // Md4 used as negative error code. 2896​ return algorithms;
2864 return QCryptographicHash::Md4; ​
2865} 2897​}
2866 2898​
2867void KChecksumsPlugin::setDefaultState() 2899​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(); 2961​ d->m_ui.feedbackLabel->show();
2930} 2962​}
2931 2963​
2932void KChecksumsPlugin::showChecksum(QCryptographicHash::Algorithm algorithm, QLabel *label, QPushButton *copyButton) 2964​void KChecksumsPlugin::showMatchedChecksum()
2965​{
2966​ for (const auto alg : d->cache.keys()) {
2967​ if(d->m_ui.lineEdit->text() == d->cache.value(alg, "")) {
2968​ showChecksum(alg);
2969​ return;
2970​ }
2971​ }
2972​}
2973​
2974​void KChecksumsPlugin::showChecksum(QCryptographicHash::Algorithm algorithm)
2933{ 2975​{
2976​ setAlgorithm(algorithm);
2977​
2978​ auto label = d->m_ui.valueLabel;
2979​ label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
2980​
2934 const QString checksum = cachedChecksum(algorithm); 2981​ const QString checksum = cachedChecksum(algorithm);
2935 2982​
2936 // Checksum in cache, nothing else to do. 2983​ // Checksum in cache, nothing else to do.
Context not available.
2948 label->setText(checksum); 2995​ label->setText(checksum);
2949 cacheChecksum(checksum, algorithm); 2996​ cacheChecksum(checksum, algorithm);
2950 2997​
2951 copyButton->show(); 2998​ d->m_ui.copyButton->show();
2952 }); 2999​ });
2953 3000​
2954 auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath()); 3001​ auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath());
2955 futureWatcher->setFuture(future); 3002​ futureWatcher->setFuture(future);
2956} 3003​}
2957 3004​
2958QString KChecksumsPlugin::cachedChecksum(QCryptographicHash::Algorithm algorithm) const 3005​void KChecksumsPlugin::writeDefaultAlgorithm(QCryptographicHash::Algorithm algorithm)
2959{ 3006​{
2960 switch (algorithm) { 3007​ d->configGroup.writeEntry("algorithm", static_cast<int>(algorithm));
2961 case QCryptographicHash::Md5: 3008​}
2962 return d->m_md5; 3009​
2963 case QCryptographicHash::Sha1: 3010​QCryptographicHash::Algorithm KChecksumsPlugin::readDefaultAlgorithm() const
2964 return d->m_sha1; 3011​{
2965 case QCryptographicHash::Sha256: 3012​ return static_cast<QCryptographicHash::Algorithm>(d->configGroup.readEntry("algorithm", static_cast<int>(QCryptographicHash::Sha256)));
2966 return d->m_sha256; 3013​}
2967 default: 3014​
2968 break; 3015​void KChecksumsPlugin::setAlgorithm(QCryptographicHash::Algorithm algorithm)
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…
3016​{
3017​ const auto *model = d->m_ui.algorithmComboBox->model();
3018​ const KChecksumAlgorithmListModel *m = dynamic_cast<const KChecksumAlgorithmListModel*>(model);
3019​ if (m) {
3020​ d->m_ui.algorithmComboBox->setCurrentIndex(m->find(algorithm));
2969 } 3021​ }
3022​}
3023​
3024​QCryptographicHash::Algorithm KChecksumsPlugin::algorithm() const
3025​{
3026​ const QAbstractItemModel *model = d->m_ui.algorithmComboBox->model();
3027​ const KChecksumAlgorithmListModel *m = dynamic_cast<const KChecksumAlgorithmListModel*>(model);
3028​ return m->at(d->m_ui.algorithmComboBox->currentIndex());
3029​}
2970 3030​
2971 return QString(); 3031​QString KChecksumsPlugin::cachedChecksum(QCryptographicHash::Algorithm algorithm) const
3032​{
3033​ return d->cache.value(algorithm, QString{});
2972} 3034​}
2973 3035​
2974void KChecksumsPlugin::cacheChecksum(const QString &checksum, QCryptographicHash::Algorithm algorithm) 3036​void KChecksumsPlugin::cacheChecksum(const QString &checksum, QCryptographicHash::Algorithm algorithm)
2975{ 3037​{
2976 switch (algorithm) { 3038​ d->cache.insert(algorithm, checksum);
2977 case QCryptographicHash::Md5: ​
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} 3039​}
2990 3040​
2991class KUrlPropsPlugin::KUrlPropsPluginPrivate 3041​class KUrlPropsPlugin::KUrlPropsPluginPrivate
Context not available.