github/qBittorrent
1
0
Fork 0
mirror of https://github.com/qbittorrent/qBittorrent synced 2025-08-14 02:27:09 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Use QList explicitly

Browse source 
PR #21016.
This commit is contained in:
Vladimir Golovnev 2024-07-04 08:30:39 +03:00 • committed by GitHub
commit 5ef2a1df07
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
95 changed files with 408 additions and 373 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/app/filelogger.cpp
View file

@ -32,8 +32,8 @@
#include <QDateTime> #include <QDateTime>
#include <QDir> #include <QDir>
#include <QList>
#include <QTextStream> #include <QTextStream>
#include <QVector>
#include "base/global.h" #include "base/global.h"
#include "base/logger.h" #include "base/logger.h"

4
src/base/bittorrent/abstractfilestorage.cpp
View file

@ -30,7 +30,7 @@
#include <QDir> #include <QDir>
#include <QHash> #include <QHash>
#include <QVector> #include <QList>
#include "base/exceptions.h" #include "base/exceptions.h"
#include "base/path.h" #include "base/path.h"
@ -71,7 +71,7 @@ void BitTorrent::AbstractFileStorage::renameFolder(const Path &oldFolderPath, co
if (newFolderPath.isAbsolute()) if (newFolderPath.isAbsolute())
throw RuntimeError(tr("Absolute path isn't allowed: '%1'.").arg(newFolderPath.toString())); throw RuntimeError(tr("Absolute path isn't allowed: '%1'.").arg(newFolderPath.toString()));
QVector<int> renamingFileIndexes; QList<int> renamingFileIndexes;
renamingFileIndexes.reserve(filesCount()); renamingFileIndexes.reserve(filesCount());
for (int i = 0; i < filesCount(); ++i) for (int i = 0; i < filesCount(); ++i)

4
src/base/bittorrent/addtorrentparams.h
View file

@ -30,9 +30,9 @@
#include <optional> #include <optional>
#include <QList>
#include <QMetaType> #include <QMetaType>
#include <QString> #include <QString>
#include <QVector>
#include "base/path.h" #include "base/path.h"
#include "base/tagset.h" #include "base/tagset.h"
@ -62,7 +62,7 @@ namespace BitTorrent
std::optional<bool> addStopped; std::optional<bool> addStopped;
std::optional<Torrent::StopCondition> stopCondition; std::optional<Torrent::StopCondition> stopCondition;
PathList filePaths; // used if TorrentInfo is set PathList filePaths; // used if TorrentInfo is set
QVector<DownloadPriority> filePriorities; // used if TorrentInfo is set QList<DownloadPriority> filePriorities; // used if TorrentInfo is set
bool skipChecking = false; bool skipChecking = false;
std::optional<BitTorrent::TorrentContentLayout> contentLayout; std::optional<BitTorrent::TorrentContentLayout> contentLayout;
std::optional<bool> useAutoTMM; std::optional<bool> useAutoTMM;

8
src/base/bittorrent/bencoderesumedatastorage.cpp
View file

@ -64,7 +64,7 @@ namespace BitTorrent
void store(const TorrentID &id, const LoadTorrentParams &resumeData) const; void store(const TorrentID &id, const LoadTorrentParams &resumeData) const;
void remove(const TorrentID &id) const; void remove(const TorrentID &id) const;
void storeQueue(const QVector<TorrentID> &queue) const; void storeQueue(const QList<TorrentID> &queue) const;
private: private:
const Path m_resumeDataDir; const Path m_resumeDataDir;
@ -134,7 +134,7 @@ BitTorrent::BencodeResumeDataStorage::BencodeResumeDataStorage(const Path &path,
m_ioThread->start(); m_ioThread->start();
} }
QVector<BitTorrent::TorrentID> BitTorrent::BencodeResumeDataStorage::registeredTorrents() const QList<BitTorrent::TorrentID> BitTorrent::BencodeResumeDataStorage::registeredTorrents() const
{ {
return m_registeredTorrents; return m_registeredTorrents;
} }
@ -354,7 +354,7 @@ void BitTorrent::BencodeResumeDataStorage::remove(const TorrentID &id) const
}); });
} }
void BitTorrent::BencodeResumeDataStorage::storeQueue(const QVector<TorrentID> &queue) const void BitTorrent::BencodeResumeDataStorage::storeQueue(const QList<TorrentID> &queue) const
{ {
QMetaObject::invokeMethod(m_asyncWorker, [this, queue]() QMetaObject::invokeMethod(m_asyncWorker, [this, queue]()
{ {
@ -460,7 +460,7 @@ void BitTorrent::BencodeResumeDataStorage::Worker::remove(const TorrentID &id) c
Utils::Fs::removeFile(m_resumeDataDir / torrentFilename); Utils::Fs::removeFile(m_resumeDataDir / torrentFilename);
} }
void BitTorrent::BencodeResumeDataStorage::Worker::storeQueue(const QVector<TorrentID> &queue) const void BitTorrent::BencodeResumeDataStorage::Worker::storeQueue(const QList<TorrentID> &queue) const
{ {
QByteArray data; QByteArray data;
data.reserve(((BitTorrent::TorrentID::length() * 2) + 1) * queue.size()); data.reserve(((BitTorrent::TorrentID::length() * 2) + 1) * queue.size());

8
src/base/bittorrent/bencoderesumedatastorage.h
View file

@ -29,7 +29,7 @@
#pragma once #pragma once
#include <QDir> #include <QDir>
#include <QVector> #include <QList>
#include "base/pathfwd.h" #include "base/pathfwd.h"
#include "base/utils/thread.h" #include "base/utils/thread.h"
@ -49,18 +49,18 @@ namespace BitTorrent
public: public:
explicit BencodeResumeDataStorage(const Path &path, QObject *parent = nullptr); explicit BencodeResumeDataStorage(const Path &path, QObject *parent = nullptr);
QVector<TorrentID> registeredTorrents() const override; QList<TorrentID> registeredTorrents() const override;
LoadResumeDataResult load(const TorrentID &id) const override; LoadResumeDataResult load(const TorrentID &id) const override;
void store(const TorrentID &id, const LoadTorrentParams &resumeData) const override; void store(const TorrentID &id, const LoadTorrentParams &resumeData) const override;
void remove(const TorrentID &id) const override; void remove(const TorrentID &id) const override;
void storeQueue(const QVector<TorrentID> &queue) const override; void storeQueue(const QList<TorrentID> &queue) const override;
private: private:
void doLoadAll() const override; void doLoadAll() const override;
void loadQueue(const Path &queueFilename); void loadQueue(const Path &queueFilename);
LoadResumeDataResult loadTorrentResumeData(const QByteArray &data, const QByteArray &metadata) const; LoadResumeDataResult loadTorrentResumeData(const QByteArray &data, const QByteArray &metadata) const;
QVector<TorrentID> m_registeredTorrents; QList<TorrentID> m_registeredTorrents;
Utils::Thread::UniquePtr m_ioThread; Utils::Thread::UniquePtr m_ioThread;
class Worker; class Worker;

30
src/base/bittorrent/dbresumedatastorage.cpp
View file

@ -41,6 +41,7 @@
#include <QByteArray> #include <QByteArray>
#include <QDebug> #include <QDebug>
#include <QList>
#include <QMutex> #include <QMutex>
#include <QSet> #include <QSet>
#include <QSqlDatabase> #include <QSqlDatabase>
@ -48,7 +49,6 @@
#include <QSqlQuery> #include <QSqlQuery>
#include <QSqlRecord> #include <QSqlRecord>
#include <QThread> #include <QThread>
#include <QVector>
#include <QWaitCondition> #include <QWaitCondition>
#include "base/exceptions.h" #include "base/exceptions.h"
@ -107,11 +107,11 @@ namespace
class StoreQueueJob final : public Job class StoreQueueJob final : public Job
{ {
public: public:
explicit StoreQueueJob(const QVector<TorrentID> &queue); explicit StoreQueueJob(const QList<TorrentID> &queue);
void perform(QSqlDatabase db) override; void perform(QSqlDatabase db) override;
private: private:
const QVector<TorrentID> m_queue; const QList<TorrentID> m_queue;
}; };
struct Column struct Column
@ -168,7 +168,7 @@ namespace
return u"CREATE TABLE %1 (%2)"_s.arg(quoted(tableName), items.join(u',')); return u"CREATE TABLE %1 (%2)"_s.arg(quoted(tableName), items.join(u','));
} }
std::pair<QString, QString> joinColumns(const QVector<Column> &columns) std::pair<QString, QString> joinColumns(const QList<Column> &columns)
{ {
int namesSize = columns.size(); int namesSize = columns.size();
int valuesSize = columns.size(); int valuesSize = columns.size();
@ -193,21 +193,21 @@ namespace
return std::make_pair(names, values); return std::make_pair(names, values);
} }
QString makeInsertStatement(const QString &tableName, const QVector<Column> &columns) QString makeInsertStatement(const QString &tableName, const QList<Column> &columns)
{ {
const auto [names, values] = joinColumns(columns); const auto [names, values] = joinColumns(columns);
return u"INSERT INTO %1 (%2) VALUES (%3)"_s return u"INSERT INTO %1 (%2) VALUES (%3)"_s
.arg(quoted(tableName), names, values); .arg(quoted(tableName), names, values);
} }
QString makeUpdateStatement(const QString &tableName, const QVector<Column> &columns) QString makeUpdateStatement(const QString &tableName, const QList<Column> &columns)
{ {
const auto [names, values] = joinColumns(columns); const auto [names, values] = joinColumns(columns);
return u"UPDATE %1 SET (%2) = (%3)"_s return u"UPDATE %1 SET (%2) = (%3)"_s
.arg(quoted(tableName), names, values); .arg(quoted(tableName), names, values);
} }
QString makeOnConflictUpdateStatement(const Column &constraint, const QVector<Column> &columns) QString makeOnConflictUpdateStatement(const Column &constraint, const QList<Column> &columns)
{ {
const auto [names, values] = joinColumns(columns); const auto [names, values] = joinColumns(columns);
return u" ON CONFLICT (%1) DO UPDATE SET (%2) = (%3)"_s return u" ON CONFLICT (%1) DO UPDATE SET (%2) = (%3)"_s
@ -308,7 +308,7 @@ namespace BitTorrent
void store(const TorrentID &id, const LoadTorrentParams &resumeData); void store(const TorrentID &id, const LoadTorrentParams &resumeData);
void remove(const TorrentID &id); void remove(const TorrentID &id);
void storeQueue(const QVector<TorrentID> &queue); void storeQueue(const QList<TorrentID> &queue);
private: private:
void addJob(std::unique_ptr<Job> job); void addJob(std::unique_ptr<Job> job);
@ -356,7 +356,7 @@ BitTorrent::DBResumeDataStorage::~DBResumeDataStorage()
QSqlDatabase::removeDatabase(DB_CONNECTION_NAME); QSqlDatabase::removeDatabase(DB_CONNECTION_NAME);
} }
QVector<BitTorrent::TorrentID> BitTorrent::DBResumeDataStorage::registeredTorrents() const QList<BitTorrent::TorrentID> BitTorrent::DBResumeDataStorage::registeredTorrents() const
{ {
const auto selectTorrentIDStatement = u"SELECT %1 FROM %2 ORDER BY %3;"_s const auto selectTorrentIDStatement = u"SELECT %1 FROM %2 ORDER BY %3;"_s
.arg(quoted(DB_COLUMN_TORRENT_ID.name), quoted(DB_TABLE_TORRENTS), quoted(DB_COLUMN_QUEUE_POSITION.name)); .arg(quoted(DB_COLUMN_TORRENT_ID.name), quoted(DB_TABLE_TORRENTS), quoted(DB_COLUMN_QUEUE_POSITION.name));
@ -367,7 +367,7 @@ QVector<BitTorrent::TorrentID> BitTorrent::DBResumeDataStorage::registeredTorren
if (!query.exec(selectTorrentIDStatement)) if (!query.exec(selectTorrentIDStatement))
throw RuntimeError(query.lastError().text()); throw RuntimeError(query.lastError().text());
QVector<TorrentID> registeredTorrents; QList<TorrentID> registeredTorrents;
registeredTorrents.reserve(query.size()); registeredTorrents.reserve(query.size());
while (query.next()) while (query.next())
registeredTorrents.append(BitTorrent::TorrentID::fromString(query.value(0).toString())); registeredTorrents.append(BitTorrent::TorrentID::fromString(query.value(0).toString()));
@ -413,7 +413,7 @@ void BitTorrent::DBResumeDataStorage::remove(const BitTorrent::TorrentID &id) co
m_asyncWorker->remove(id); m_asyncWorker->remove(id);
} }
void BitTorrent::DBResumeDataStorage::storeQueue(const QVector<TorrentID> &queue) const void BitTorrent::DBResumeDataStorage::storeQueue(const QList<TorrentID> &queue) const
{ {
m_asyncWorker->storeQueue(queue); m_asyncWorker->storeQueue(queue);
} }
@ -438,7 +438,7 @@ void BitTorrent::DBResumeDataStorage::doLoadAll() const
if (!query.exec(selectTorrentIDStatement)) if (!query.exec(selectTorrentIDStatement))
throw RuntimeError(query.lastError().text()); throw RuntimeError(query.lastError().text());
QVector<TorrentID> registeredTorrents; QList<TorrentID> registeredTorrents;
registeredTorrents.reserve(query.size()); registeredTorrents.reserve(query.size());
while (query.next()) while (query.next())
registeredTorrents.append(TorrentID::fromString(query.value(0).toString())); registeredTorrents.append(TorrentID::fromString(query.value(0).toString()));
@ -747,7 +747,7 @@ void BitTorrent::DBResumeDataStorage::Worker::remove(const TorrentID &id)
addJob(std::make_unique<RemoveJob>(id)); addJob(std::make_unique<RemoveJob>(id));
} }
void BitTorrent::DBResumeDataStorage::Worker::storeQueue(const QVector<TorrentID> &queue) void BitTorrent::DBResumeDataStorage::Worker::storeQueue(const QList<TorrentID> &queue)
{ {
addJob(std::make_unique<StoreQueueJob>(queue)); addJob(std::make_unique<StoreQueueJob>(queue));
} }
@ -797,7 +797,7 @@ namespace
} }
} }
QVector<Column> columns { QList<Column> columns {
DB_COLUMN_TORRENT_ID, DB_COLUMN_TORRENT_ID,
DB_COLUMN_NAME, DB_COLUMN_NAME,
DB_COLUMN_CATEGORY, DB_COLUMN_CATEGORY,
@ -929,7 +929,7 @@ namespace
} }
} }
StoreQueueJob::StoreQueueJob(const QVector<TorrentID> &queue) StoreQueueJob::StoreQueueJob(const QList<TorrentID> &queue)
: m_queue {queue} : m_queue {queue}
{ {
} }

4
src/base/bittorrent/dbresumedatastorage.h
View file

@ -47,12 +47,12 @@ namespace BitTorrent
explicit DBResumeDataStorage(const Path &dbPath, QObject *parent = nullptr); explicit DBResumeDataStorage(const Path &dbPath, QObject *parent = nullptr);
~DBResumeDataStorage() override; ~DBResumeDataStorage() override;
QVector<TorrentID> registeredTorrents() const override; QList<TorrentID> registeredTorrents() const override;
LoadResumeDataResult load(const TorrentID &id) const override; LoadResumeDataResult load(const TorrentID &id) const override;
void store(const TorrentID &id, const LoadTorrentParams &resumeData) const override; void store(const TorrentID &id, const LoadTorrentParams &resumeData) const override;
void remove(const TorrentID &id) const override; void remove(const TorrentID &id) const override;
void storeQueue(const QVector<TorrentID> &queue) const override; void storeQueue(const QList<TorrentID> &queue) const override;
private: private:
void doLoadAll() const override; void doLoadAll() const override;

4
src/base/bittorrent/filterparserthread.cpp
View file

@ -133,7 +133,7 @@ int FilterParserThread::parseDATFilterFile()
return ruleCount; return ruleCount;
} }
std::vector<char> buffer(BUFFER_SIZE, 0); // seems a bit faster than QVector std::vector<char> buffer(BUFFER_SIZE, 0); // seems a bit faster than QList
qint64 bytesRead = 0; qint64 bytesRead = 0;
int offset = 0; int offset = 0;
int start = 0; int start = 0;
@ -297,7 +297,7 @@ int FilterParserThread::parseP2PFilterFile()
return ruleCount; return ruleCount;
} }
std::vector<char> buffer(BUFFER_SIZE, 0); // seems a bit faster than QVector std::vector<char> buffer(BUFFER_SIZE, 0); // seems a bit faster than QList
qint64 bytesRead = 0; qint64 bytesRead = 0;
int offset = 0; int offset = 0;
int start = 0; int start = 0;

4
src/base/bittorrent/resumedatastorage.cpp
View file

@ -30,12 +30,12 @@
#include <utility> #include <utility>
#include <QList>
#include <QMetaObject> #include <QMetaObject>
#include <QMutexLocker> #include <QMutexLocker>
#include <QThread> #include <QThread>
#include <QVector>
const int TORRENTIDLIST_TYPEID = qRegisterMetaType<QVector<BitTorrent::TorrentID>>(); const int TORRENTIDLIST_TYPEID = qRegisterMetaType<QList<BitTorrent::TorrentID>>();
BitTorrent::ResumeDataStorage::ResumeDataStorage(const Path &path, QObject *parent) BitTorrent::ResumeDataStorage::ResumeDataStorage(const Path &path, QObject *parent)
: QObject(parent) : QObject(parent)

6
src/base/bittorrent/resumedatastorage.h
View file

@ -58,17 +58,17 @@ namespace BitTorrent
Path path() const; Path path() const;
virtual QVector<TorrentID> registeredTorrents() const = 0; virtual QList<TorrentID> registeredTorrents() const = 0;
virtual LoadResumeDataResult load(const TorrentID &id) const = 0; virtual LoadResumeDataResult load(const TorrentID &id) const = 0;
virtual void store(const TorrentID &id, const LoadTorrentParams &resumeData) const = 0; virtual void store(const TorrentID &id, const LoadTorrentParams &resumeData) const = 0;
virtual void remove(const TorrentID &id) const = 0; virtual void remove(const TorrentID &id) const = 0;
virtual void storeQueue(const QVector<TorrentID> &queue) const = 0; virtual void storeQueue(const QList<TorrentID> &queue) const = 0;
void loadAll() const; void loadAll() const;
QList<LoadedResumeData> fetchLoadedResumeData() const; QList<LoadedResumeData> fetchLoadedResumeData() const;
signals: signals:
void loadStarted(const QVector<BitTorrent::TorrentID> &torrents); void loadStarted(const QList<BitTorrent::TorrentID> &torrents);
void loadFinished(); void loadFinished();
protected: protected:

16
src/base/bittorrent/session.h
View file

@ -446,7 +446,7 @@ namespace BitTorrent
virtual Torrent *getTorrent(const TorrentID &id) const = 0; virtual Torrent *getTorrent(const TorrentID &id) const = 0;
virtual Torrent *findTorrent(const InfoHash &infoHash) const = 0; virtual Torrent *findTorrent(const InfoHash &infoHash) const = 0;
virtual QVector<Torrent *> torrents() const = 0; virtual QList<Torrent *> torrents() const = 0;
virtual qsizetype torrentsCount() const = 0; virtual qsizetype torrentsCount() const = 0;
virtual const SessionStatus &status() const = 0; virtual const SessionStatus &status() const = 0;
virtual const CacheStatus &cacheStatus() const = 0; virtual const CacheStatus &cacheStatus() const = 0;
@ -460,10 +460,10 @@ namespace BitTorrent
virtual bool downloadMetadata(const TorrentDescriptor &torrentDescr) = 0; virtual bool downloadMetadata(const TorrentDescriptor &torrentDescr) = 0;
virtual bool cancelDownloadMetadata(const TorrentID &id) = 0; virtual bool cancelDownloadMetadata(const TorrentID &id) = 0;
virtual void increaseTorrentsQueuePos(const QVector<TorrentID> &ids) = 0; virtual void increaseTorrentsQueuePos(const QList<TorrentID> &ids) = 0;
virtual void decreaseTorrentsQueuePos(const QVector<TorrentID> &ids) = 0; virtual void decreaseTorrentsQueuePos(const QList<TorrentID> &ids) = 0;
virtual void topTorrentsQueuePos(const QVector<TorrentID> &ids) = 0; virtual void topTorrentsQueuePos(const QList<TorrentID> &ids) = 0;
virtual void bottomTorrentsQueuePos(const QVector<TorrentID> &ids) = 0; virtual void bottomTorrentsQueuePos(const QList<TorrentID> &ids) = 0;
signals: signals:
void startupProgressUpdated(int progress); void startupProgressUpdated(int progress);
@ -494,12 +494,12 @@ namespace BitTorrent
void torrentStarted(Torrent *torrent); void torrentStarted(Torrent *torrent);
void torrentSavePathChanged(Torrent *torrent); void torrentSavePathChanged(Torrent *torrent);
void torrentSavingModeChanged(Torrent *torrent); void torrentSavingModeChanged(Torrent *torrent);
void torrentsLoaded(const QVector<Torrent *> &torrents); void torrentsLoaded(const QList<Torrent *> &torrents);
void torrentsUpdated(const QVector<Torrent *> &torrents); void torrentsUpdated(const QList<Torrent *> &torrents);
void torrentTagAdded(Torrent *torrent, const Tag &tag); void torrentTagAdded(Torrent *torrent, const Tag &tag);
void torrentTagRemoved(Torrent *torrent, const Tag &tag); void torrentTagRemoved(Torrent *torrent, const Tag &tag);
void trackerError(Torrent *torrent, const QString &tracker); void trackerError(Torrent *torrent, const QString &tracker);
void trackersAdded(Torrent *torrent, const QVector<TrackerEntry> &trackers); void trackersAdded(Torrent *torrent, const QList<TrackerEntry> &trackers);
void trackersChanged(Torrent *torrent); void trackersChanged(Torrent *torrent);
void trackersRemoved(Torrent *torrent, const QStringList &trackers); void trackersRemoved(Torrent *torrent, const QStringList &trackers);
void trackerSuccess(Torrent *torrent, const QString &tracker); void trackerSuccess(Torrent *torrent, const QString &tracker);

26
src/base/bittorrent/sessionimpl.cpp
View file

@ -1306,7 +1306,7 @@ void SessionImpl::prepareStartup()
context->startupStorage = m_resumeDataStorage; context->startupStorage = m_resumeDataStorage;
connect(context->startupStorage, &ResumeDataStorage::loadStarted, context connect(context->startupStorage, &ResumeDataStorage::loadStarted, context
, [this, context](const QVector<TorrentID> &torrents) , [this, context](const QList<TorrentID> &torrents)
{ {
context->totalResumeDataCount = torrents.size(); context->totalResumeDataCount = torrents.size();
#ifdef QBT_USES_LIBTORRENT2 #ifdef QBT_USES_LIBTORRENT2
@ -2491,7 +2491,7 @@ bool SessionImpl::cancelDownloadMetadata(const TorrentID &id)
return true; return true;
} }
void SessionImpl::increaseTorrentsQueuePos(const QVector<TorrentID> &ids) void SessionImpl::increaseTorrentsQueuePos(const QList<TorrentID> &ids)
{ {
using ElementType = std::pair<int, const TorrentImpl *>; using ElementType = std::pair<int, const TorrentImpl *>;
std::priority_queue<ElementType std::priority_queue<ElementType
@ -2518,7 +2518,7 @@ void SessionImpl::increaseTorrentsQueuePos(const QVector<TorrentID> &ids)
m_torrentsQueueChanged = true; m_torrentsQueueChanged = true;
} }
void SessionImpl::decreaseTorrentsQueuePos(const QVector<TorrentID> &ids) void SessionImpl::decreaseTorrentsQueuePos(const QList<TorrentID> &ids)
{ {
using ElementType = std::pair<int, const TorrentImpl *>; using ElementType = std::pair<int, const TorrentImpl *>;
std::priority_queue<ElementType> torrentQueue; std::priority_queue<ElementType> torrentQueue;
@ -2546,7 +2546,7 @@ void SessionImpl::decreaseTorrentsQueuePos(const QVector<TorrentID> &ids)
m_torrentsQueueChanged = true; m_torrentsQueueChanged = true;
} }
void SessionImpl::topTorrentsQueuePos(const QVector<TorrentID> &ids) void SessionImpl::topTorrentsQueuePos(const QList<TorrentID> &ids)
{ {
using ElementType = std::pair<int, const TorrentImpl *>; using ElementType = std::pair<int, const TorrentImpl *>;
std::priority_queue<ElementType> torrentQueue; std::priority_queue<ElementType> torrentQueue;
@ -2571,7 +2571,7 @@ void SessionImpl::topTorrentsQueuePos(const QVector<TorrentID> &ids)
m_torrentsQueueChanged = true; m_torrentsQueueChanged = true;
} }
void SessionImpl::bottomTorrentsQueuePos(const QVector<TorrentID> &ids) void SessionImpl::bottomTorrentsQueuePos(const QList<TorrentID> &ids)
{ {
using ElementType = std::pair<int, const TorrentImpl *>; using ElementType = std::pair<int, const TorrentImpl *>;
std::priority_queue<ElementType std::priority_queue<ElementType
@ -2607,9 +2607,9 @@ void SessionImpl::handleTorrentResumeDataRequested(const TorrentImpl *torrent)
++m_numResumeData; ++m_numResumeData;
} }
QVector<Torrent *> SessionImpl::torrents() const QList<Torrent *> SessionImpl::torrents() const
{ {
QVector<Torrent *> result; QList<Torrent *> result;
result.reserve(m_torrents.size()); result.reserve(m_torrents.size());
for (TorrentImpl *torrent : asConst(m_torrents)) for (TorrentImpl *torrent : asConst(m_torrents))
result << torrent; result << torrent;
@ -3133,7 +3133,7 @@ void SessionImpl::saveResumeData()
void SessionImpl::saveTorrentsQueue() void SessionImpl::saveTorrentsQueue()
{ {
QVector<TorrentID> queue; QList<TorrentID> queue;
for (const TorrentImpl *torrent : asConst(m_torrents)) for (const TorrentImpl *torrent : asConst(m_torrents))
{ {
if (const int queuePos = torrent->queuePosition(); queuePos >= 0) if (const int queuePos = torrent->queuePosition(); queuePos >= 0)
@ -4985,7 +4985,7 @@ void SessionImpl::handleTorrentSavingModeChanged(TorrentImpl *const torrent)
emit torrentSavingModeChanged(torrent); emit torrentSavingModeChanged(torrent);
} }
void SessionImpl::handleTorrentTrackersAdded(TorrentImpl *const torrent, const QVector<TrackerEntry> &newTrackers) void SessionImpl::handleTorrentTrackersAdded(TorrentImpl *const torrent, const QList<TrackerEntry> &newTrackers)
{ {
for (const TrackerEntry &newTracker : newTrackers) for (const TrackerEntry &newTracker : newTrackers)
LogMsg(tr("Added tracker to torrent. Torrent: \"%1\". Tracker: \"%2\"").arg(torrent->name(), newTracker.url)); LogMsg(tr("Added tracker to torrent. Torrent: \"%1\". Tracker: \"%2\"").arg(torrent->name(), newTracker.url));
@ -5004,13 +5004,13 @@ void SessionImpl::handleTorrentTrackersChanged(TorrentImpl *const torrent)
emit trackersChanged(torrent); emit trackersChanged(torrent);
} }
void SessionImpl::handleTorrentUrlSeedsAdded(TorrentImpl *const torrent, const QVector<QUrl> &newUrlSeeds) void SessionImpl::handleTorrentUrlSeedsAdded(TorrentImpl *const torrent, const QList<QUrl> &newUrlSeeds)
{ {
for (const QUrl &newUrlSeed : newUrlSeeds) for (const QUrl &newUrlSeed : newUrlSeeds)
LogMsg(tr("Added URL seed to torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), newUrlSeed.toString())); LogMsg(tr("Added URL seed to torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), newUrlSeed.toString()));
} }
void SessionImpl::handleTorrentUrlSeedsRemoved(TorrentImpl *const torrent, const QVector<QUrl> &urlSeeds) void SessionImpl::handleTorrentUrlSeedsRemoved(TorrentImpl *const torrent, const QList<QUrl> &urlSeeds)
{ {
for (const QUrl &urlSeed : urlSeeds) for (const QUrl &urlSeed : urlSeeds)
LogMsg(tr("Removed URL seed from torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), urlSeed.toString())); LogMsg(tr("Removed URL seed from torrent. Torrent: \"%1\". URL: \"%2\"").arg(torrent->name(), urlSeed.toString()));
@ -5028,7 +5028,7 @@ void SessionImpl::handleTorrentStopped(TorrentImpl *const torrent)
{ {
torrent->resetTrackerEntryStatuses(); torrent->resetTrackerEntryStatuses();
const QVector<TrackerEntryStatus> trackers = torrent->trackers(); const QList<TrackerEntryStatus> trackers = torrent->trackers();
QHash<QString, TrackerEntryStatus> updatedTrackers; QHash<QString, TrackerEntryStatus> updatedTrackers;
updatedTrackers.reserve(trackers.size()); updatedTrackers.reserve(trackers.size());
@ -6056,7 +6056,7 @@ void SessionImpl::handleStorageMovedFailedAlert(const lt::storage_moved_failed_a
void SessionImpl::handleStateUpdateAlert(const lt::state_update_alert *alert) void SessionImpl::handleStateUpdateAlert(const lt::state_update_alert *alert)
{ {
QVector<Torrent *> updatedTorrents; QList<Torrent *> updatedTorrents;
updatedTorrents.reserve(static_cast<decltype(updatedTorrents)::size_type>(alert->status.size())); updatedTorrents.reserve(static_cast<decltype(updatedTorrents)::size_type>(alert->status.size()));
for (const lt::torrent_status &status : alert->status) for (const lt::torrent_status &status : alert->status)

22
src/base/bittorrent/sessionimpl.h
View file

@ -40,10 +40,10 @@
#include <QDateTime> #include <QDateTime>
#include <QElapsedTimer> #include <QElapsedTimer>
#include <QHash> #include <QHash>
#include <QList>
#include <QMap> #include <QMap>
#include <QPointer> #include <QPointer>
#include <QSet> #include <QSet>
#include <QVector>
#include "base/path.h" #include "base/path.h"
#include "base/settingvalue.h" #include "base/settingvalue.h"
@ -423,7 +423,7 @@ namespace BitTorrent
Torrent *getTorrent(const TorrentID &id) const override; Torrent *getTorrent(const TorrentID &id) const override;
Torrent *findTorrent(const InfoHash &infoHash) const override; Torrent *findTorrent(const InfoHash &infoHash) const override;
QVector<Torrent *> torrents() const override; QList<Torrent *> torrents() const override;
qsizetype torrentsCount() const override; qsizetype torrentsCount() const override;
const SessionStatus &status() const override; const SessionStatus &status() const override;
const CacheStatus &cacheStatus() const override; const CacheStatus &cacheStatus() const override;
@ -437,10 +437,10 @@ namespace BitTorrent
bool downloadMetadata(const TorrentDescriptor &torrentDescr) override; bool downloadMetadata(const TorrentDescriptor &torrentDescr) override;
bool cancelDownloadMetadata(const TorrentID &id) override; bool cancelDownloadMetadata(const TorrentID &id) override;
void increaseTorrentsQueuePos(const QVector<TorrentID> &ids) override; void increaseTorrentsQueuePos(const QList<TorrentID> &ids) override;
void decreaseTorrentsQueuePos(const QVector<TorrentID> &ids) override; void decreaseTorrentsQueuePos(const QList<TorrentID> &ids) override;
void topTorrentsQueuePos(const QVector<TorrentID> &ids) override; void topTorrentsQueuePos(const QList<TorrentID> &ids) override;
void bottomTorrentsQueuePos(const QVector<TorrentID> &ids) override; void bottomTorrentsQueuePos(const QList<TorrentID> &ids) override;
// Torrent interface // Torrent interface
void handleTorrentResumeDataRequested(const TorrentImpl *torrent); void handleTorrentResumeDataRequested(const TorrentImpl *torrent);
@ -456,11 +456,11 @@ namespace BitTorrent
void handleTorrentStarted(TorrentImpl *torrent); void handleTorrentStarted(TorrentImpl *torrent);
void handleTorrentChecked(TorrentImpl *torrent); void handleTorrentChecked(TorrentImpl *torrent);
void handleTorrentFinished(TorrentImpl *torrent); void handleTorrentFinished(TorrentImpl *torrent);
void handleTorrentTrackersAdded(TorrentImpl *torrent, const QVector<TrackerEntry> &newTrackers); void handleTorrentTrackersAdded(TorrentImpl *torrent, const QList<TrackerEntry> &newTrackers);
void handleTorrentTrackersRemoved(TorrentImpl *torrent, const QStringList &deletedTrackers); void handleTorrentTrackersRemoved(TorrentImpl *torrent, const QStringList &deletedTrackers);
void handleTorrentTrackersChanged(TorrentImpl *torrent); void handleTorrentTrackersChanged(TorrentImpl *torrent);
void handleTorrentUrlSeedsAdded(TorrentImpl *torrent, const QVector<QUrl> &newUrlSeeds); void handleTorrentUrlSeedsAdded(TorrentImpl *torrent, const QList<QUrl> &newUrlSeeds);
void handleTorrentUrlSeedsRemoved(TorrentImpl *torrent, const QVector<QUrl> &urlSeeds); void handleTorrentUrlSeedsRemoved(TorrentImpl *torrent, const QList<QUrl> &urlSeeds);
void handleTorrentResumeDataReady(TorrentImpl *torrent, const LoadTorrentParams &data); void handleTorrentResumeDataReady(TorrentImpl *torrent, const LoadTorrentParams &data);
void handleTorrentInfoHashChanged(TorrentImpl *torrent, const InfoHash &prevInfoHash); void handleTorrentInfoHashChanged(TorrentImpl *torrent, const InfoHash &prevInfoHash);
void handleTorrentStorageMovingStateChanged(TorrentImpl *torrent); void handleTorrentStorageMovingStateChanged(TorrentImpl *torrent);
@ -749,8 +749,8 @@ namespace BitTorrent
const bool m_wasPexEnabled = m_isPeXEnabled; const bool m_wasPexEnabled = m_isPeXEnabled;
int m_numResumeData = 0; int m_numResumeData = 0;
QVector<TrackerEntry> m_additionalTrackerEntries; QList<TrackerEntry> m_additionalTrackerEntries;
QVector<QRegularExpression> m_excludedFileNamesRegExpList; QList<QRegularExpression> m_excludedFileNamesRegExpList;
// Statistics // Statistics
mutable QElapsedTimer m_statisticsLastUpdateTimer; mutable QElapsedTimer m_statisticsLastUpdateTimer;

22
src/base/bittorrent/torrent.h
View file

@ -249,8 +249,8 @@ namespace BitTorrent
virtual bool hasMissingFiles() const = 0; virtual bool hasMissingFiles() const = 0;
virtual bool hasError() const = 0; virtual bool hasError() const = 0;
virtual int queuePosition() const = 0; virtual int queuePosition() const = 0;
virtual QVector<TrackerEntryStatus> trackers() const = 0; virtual QList<TrackerEntryStatus> trackers() const = 0;
virtual QVector<QUrl> urlSeeds() const = 0; virtual QList<QUrl> urlSeeds() const = 0;
virtual QString error() const = 0; virtual QString error() const = 0;
virtual qlonglong totalDownload() const = 0; virtual qlonglong totalDownload() const = 0;
virtual qlonglong totalUpload() const = 0; virtual qlonglong totalUpload() const = 0;
@ -274,10 +274,10 @@ namespace BitTorrent
virtual bool isDHTDisabled() const = 0; virtual bool isDHTDisabled() const = 0;
virtual bool isPEXDisabled() const = 0; virtual bool isPEXDisabled() const = 0;
virtual bool isLSDDisabled() const = 0; virtual bool isLSDDisabled() const = 0;
virtual QVector<PeerInfo> peers() const = 0; virtual QList<PeerInfo> peers() const = 0;
virtual QBitArray pieces() const = 0; virtual QBitArray pieces() const = 0;
virtual QBitArray downloadingPieces() const = 0; virtual QBitArray downloadingPieces() const = 0;
virtual QVector<int> pieceAvailability() const = 0; virtual QList<int> pieceAvailability() const = 0;
virtual qreal distributedCopies() const = 0; virtual qreal distributedCopies() const = 0;
virtual qreal maxRatio() const = 0; virtual qreal maxRatio() const = 0;
virtual int maxSeedingTime() const = 0; virtual int maxSeedingTime() const = 0;
@ -306,11 +306,11 @@ namespace BitTorrent
virtual void setDHTDisabled(bool disable) = 0; virtual void setDHTDisabled(bool disable) = 0;
virtual void setPEXDisabled(bool disable) = 0; virtual void setPEXDisabled(bool disable) = 0;
virtual void setLSDDisabled(bool disable) = 0; virtual void setLSDDisabled(bool disable) = 0;
virtual void addTrackers(QVector<TrackerEntry> trackers) = 0; virtual void addTrackers(QList<TrackerEntry> trackers) = 0;
virtual void removeTrackers(const QStringList &trackers) = 0; virtual void removeTrackers(const QStringList &trackers) = 0;
virtual void replaceTrackers(QVector<TrackerEntry> trackers) = 0; virtual void replaceTrackers(QList<TrackerEntry> trackers) = 0;
virtual void addUrlSeeds(const QVector<QUrl> &urlSeeds) = 0; virtual void addUrlSeeds(const QList<QUrl> &urlSeeds) = 0;
virtual void removeUrlSeeds(const QVector<QUrl> &urlSeeds) = 0; virtual void removeUrlSeeds(const QList<QUrl> &urlSeeds) = 0;
virtual bool connectPeer(const PeerAddress &peerAddress) = 0; virtual bool connectPeer(const PeerAddress &peerAddress) = 0;
virtual void clearPeers() = 0; virtual void clearPeers() = 0;
virtual void setMetadata(const TorrentInfo &torrentInfo) = 0; virtual void setMetadata(const TorrentInfo &torrentInfo) = 0;
@ -324,9 +324,9 @@ namespace BitTorrent
virtual nonstd::expected<QByteArray, QString> exportToBuffer() const = 0; virtual nonstd::expected<QByteArray, QString> exportToBuffer() const = 0;
virtual nonstd::expected<void, QString> exportToFile(const Path &path) const = 0; virtual nonstd::expected<void, QString> exportToFile(const Path &path) const = 0;
virtual void fetchPeerInfo(std::function<void (QVector<PeerInfo>)> resultHandler) const = 0; virtual void fetchPeerInfo(std::function<void (QList<PeerInfo>)> resultHandler) const = 0;
virtual void fetchURLSeeds(std::function<void (QVector<QUrl>)> resultHandler) const = 0; virtual void fetchURLSeeds(std::function<void (QList<QUrl>)> resultHandler) const = 0;
virtual void fetchPieceAvailability(std::function<void (QVector<int>)> resultHandler) const = 0; virtual void fetchPieceAvailability(std::function<void (QList<int>)> resultHandler) const = 0;
virtual void fetchDownloadingPieces(std::function<void (QBitArray)> resultHandler) const = 0; virtual void fetchDownloadingPieces(std::function<void (QBitArray)> resultHandler) const = 0;
TorrentID id() const; TorrentID id() const;

10
src/base/bittorrent/torrentcontenthandler.h
View file

@ -44,18 +44,18 @@ namespace BitTorrent
virtual bool hasMetadata() const = 0; virtual bool hasMetadata() const = 0;
virtual Path actualStorageLocation() const = 0; virtual Path actualStorageLocation() const = 0;
virtual Path actualFilePath(int fileIndex) const = 0; virtual Path actualFilePath(int fileIndex) const = 0;
virtual QVector<DownloadPriority> filePriorities() const = 0; virtual QList<DownloadPriority> filePriorities() const = 0;
virtual QVector<qreal> filesProgress() const = 0; virtual QList<qreal> filesProgress() const = 0;
/** /**
* @brief fraction of file pieces that are available at least from one peer * @brief fraction of file pieces that are available at least from one peer
* *
* This is not the same as torrrent availability, it is just a fraction of pieces * This is not the same as torrrent availability, it is just a fraction of pieces
* that can be downloaded right now. It varies between 0 to 1. * that can be downloaded right now. It varies between 0 to 1.
*/ */
virtual QVector<qreal> availableFileFractions() const = 0; virtual QList<qreal> availableFileFractions() const = 0;
virtual void fetchAvailableFileFractions(std::function<void (QVector<qreal>)> resultHandler) const = 0; virtual void fetchAvailableFileFractions(std::function<void (QList<qreal>)> resultHandler) const = 0;
virtual void prioritizeFiles(const QVector<DownloadPriority> &priorities) = 0; virtual void prioritizeFiles(const QList<DownloadPriority> &priorities) = 0;
virtual void flushCache() const = 0; virtual void flushCache() const = 0;
}; };
} }

8
src/base/bittorrent/torrentdescriptor.cpp
View file

@ -204,9 +204,9 @@ void BitTorrent::TorrentDescriptor::setTorrentInfo(TorrentInfo torrentInfo)
} }
} }
QVector<BitTorrent::TrackerEntry> BitTorrent::TorrentDescriptor::trackers() const QList<BitTorrent::TrackerEntry> BitTorrent::TorrentDescriptor::trackers() const
{ {
QVector<TrackerEntry> ret; QList<TrackerEntry> ret;
ret.reserve(static_cast<decltype(ret)::size_type>(m_ltAddTorrentParams.trackers.size())); ret.reserve(static_cast<decltype(ret)::size_type>(m_ltAddTorrentParams.trackers.size()));
std::size_t i = 0; std::size_t i = 0;
for (const std::string &tracker : m_ltAddTorrentParams.trackers) for (const std::string &tracker : m_ltAddTorrentParams.trackers)
@ -215,9 +215,9 @@ QVector<BitTorrent::TrackerEntry> BitTorrent::TorrentDescriptor::trackers() cons
return ret; return ret;
} }
QVector<QUrl> BitTorrent::TorrentDescriptor::urlSeeds() const QList<QUrl> BitTorrent::TorrentDescriptor::urlSeeds() const
{ {
QVector<QUrl> urlSeeds; QList<QUrl> urlSeeds;
urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(m_ltAddTorrentParams.url_seeds.size())); urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(m_ltAddTorrentParams.url_seeds.size()));
for (const std::string &nativeURLSeed : m_ltAddTorrentParams.url_seeds) for (const std::string &nativeURLSeed : m_ltAddTorrentParams.url_seeds)

4
src/base/bittorrent/torrentdescriptor.h
View file

@ -60,8 +60,8 @@ namespace BitTorrent
QDateTime creationDate() const; QDateTime creationDate() const;
QString creator() const; QString creator() const;
QString comment() const; QString comment() const;
QVector<TrackerEntry> trackers() const; QList<TrackerEntry> trackers() const;
QVector<QUrl> urlSeeds() const; QList<QUrl> urlSeeds() const;
const std::optional<TorrentInfo> &info() const; const std::optional<TorrentInfo> &info() const;
void setTorrentInfo(TorrentInfo torrentInfo); void setTorrentInfo(TorrentInfo torrentInfo);

82
src/base/bittorrent/torrentimpl.cpp
View file

@ -606,12 +606,12 @@ Path TorrentImpl::makeUserPath(const Path &path) const
return userPath; return userPath;
} }
QVector<TrackerEntryStatus> TorrentImpl::trackers() const QList<TrackerEntryStatus> TorrentImpl::trackers() const
{ {
return m_trackerEntryStatuses; return m_trackerEntryStatuses;
} }
void TorrentImpl::addTrackers(QVector<TrackerEntry> trackers) void TorrentImpl::addTrackers(QList<TrackerEntry> trackers)
{ {
trackers.removeIf([](const TrackerEntry &trackerEntry) { return trackerEntry.url.isEmpty(); }); trackers.removeIf([](const TrackerEntry &trackerEntry) { return trackerEntry.url.isEmpty(); });
@ -624,7 +624,7 @@ void TorrentImpl::addTrackers(QVector<TrackerEntry> trackers)
if (newTrackerSet.isEmpty()) if (newTrackerSet.isEmpty())
return; return;
trackers = QVector<TrackerEntry>(newTrackerSet.cbegin(), newTrackerSet.cend()); trackers = QList<TrackerEntry>(newTrackerSet.cbegin(), newTrackerSet.cend());
for (const TrackerEntry &tracker : asConst(trackers)) for (const TrackerEntry &tracker : asConst(trackers))
{ {
m_nativeHandle.add_tracker(makeNativeAnnounceEntry(tracker.url, tracker.tier)); m_nativeHandle.add_tracker(makeNativeAnnounceEntry(tracker.url, tracker.tier));
@ -660,13 +660,13 @@ void TorrentImpl::removeTrackers(const QStringList &trackers)
} }
} }
void TorrentImpl::replaceTrackers(QVector<TrackerEntry> trackers) void TorrentImpl::replaceTrackers(QList<TrackerEntry> trackers)
{ {
trackers.removeIf([](const TrackerEntry &trackerEntry) { return trackerEntry.url.isEmpty(); }); trackers.removeIf([](const TrackerEntry &trackerEntry) { return trackerEntry.url.isEmpty(); });
// Filter out duplicate trackers // Filter out duplicate trackers
const auto uniqueTrackers = QSet<TrackerEntry>(trackers.cbegin(), trackers.cend()); const auto uniqueTrackers = QSet<TrackerEntry>(trackers.cbegin(), trackers.cend());
trackers = QVector<TrackerEntry>(uniqueTrackers.cbegin(), uniqueTrackers.cend()); trackers = QList<TrackerEntry>(uniqueTrackers.cbegin(), uniqueTrackers.cend());
std::sort(trackers.begin(), trackers.end() std::sort(trackers.begin(), trackers.end()
, [](const TrackerEntry &left, const TrackerEntry &right) { return left.tier < right.tier; }); , [](const TrackerEntry &left, const TrackerEntry &right) { return left.tier < right.tier; });
@ -691,12 +691,12 @@ void TorrentImpl::replaceTrackers(QVector<TrackerEntry> trackers)
m_session->handleTorrentTrackersChanged(this); m_session->handleTorrentTrackersChanged(this);
} }
QVector<QUrl> TorrentImpl::urlSeeds() const QList<QUrl> TorrentImpl::urlSeeds() const
{ {
return m_urlSeeds; return m_urlSeeds;
} }
void TorrentImpl::addUrlSeeds(const QVector<QUrl> &urlSeeds) void TorrentImpl::addUrlSeeds(const QList<QUrl> &urlSeeds)
{ {
m_session->invokeAsync([urlSeeds, session = m_session m_session->invokeAsync([urlSeeds, session = m_session
, nativeHandle = m_nativeHandle , nativeHandle = m_nativeHandle
@ -705,12 +705,12 @@ void TorrentImpl::addUrlSeeds(const QVector<QUrl> &urlSeeds)
try try
{ {
const std::set<std::string> nativeSeeds = nativeHandle.url_seeds(); const std::set<std::string> nativeSeeds = nativeHandle.url_seeds();
QVector<QUrl> currentSeeds; QList<QUrl> currentSeeds;
currentSeeds.reserve(static_cast<decltype(currentSeeds)::size_type>(nativeSeeds.size())); currentSeeds.reserve(static_cast<decltype(currentSeeds)::size_type>(nativeSeeds.size()));
for (const std::string &urlSeed : nativeSeeds) for (const std::string &urlSeed : nativeSeeds)
currentSeeds.append(QString::fromStdString(urlSeed)); currentSeeds.append(QString::fromStdString(urlSeed));
QVector<QUrl> addedUrlSeeds; QList<QUrl> addedUrlSeeds;
addedUrlSeeds.reserve(urlSeeds.size()); addedUrlSeeds.reserve(urlSeeds.size());
for (const QUrl &url : urlSeeds) for (const QUrl &url : urlSeeds)
@ -740,7 +740,7 @@ void TorrentImpl::addUrlSeeds(const QVector<QUrl> &urlSeeds)
}); });
} }
void TorrentImpl::removeUrlSeeds(const QVector<QUrl> &urlSeeds) void TorrentImpl::removeUrlSeeds(const QList<QUrl> &urlSeeds)
{ {
m_session->invokeAsync([urlSeeds, session = m_session m_session->invokeAsync([urlSeeds, session = m_session
, nativeHandle = m_nativeHandle , nativeHandle = m_nativeHandle
@ -749,12 +749,12 @@ void TorrentImpl::removeUrlSeeds(const QVector<QUrl> &urlSeeds)
try try
{ {
const std::set<std::string> nativeSeeds = nativeHandle.url_seeds(); const std::set<std::string> nativeSeeds = nativeHandle.url_seeds();
QVector<QUrl> currentSeeds; QList<QUrl> currentSeeds;
currentSeeds.reserve(static_cast<decltype(currentSeeds)::size_type>(nativeSeeds.size())); currentSeeds.reserve(static_cast<decltype(currentSeeds)::size_type>(nativeSeeds.size()));
for (const std::string &urlSeed : nativeSeeds) for (const std::string &urlSeed : nativeSeeds)
currentSeeds.append(QString::fromStdString(urlSeed)); currentSeeds.append(QString::fromStdString(urlSeed));
QVector<QUrl> removedUrlSeeds; QList<QUrl> removedUrlSeeds;
removedUrlSeeds.reserve(urlSeeds.size()); removedUrlSeeds.reserve(urlSeeds.size());
for (const QUrl &url : urlSeeds) for (const QUrl &url : urlSeeds)
@ -966,7 +966,7 @@ Path TorrentImpl::filePath(const int index) const
Path TorrentImpl::actualFilePath(const int index) const Path TorrentImpl::actualFilePath(const int index) const
{ {
const QVector<lt::file_index_t> nativeIndexes = m_torrentInfo.nativeIndexes(); const QList<lt::file_index_t> nativeIndexes = m_torrentInfo.nativeIndexes();
Q_ASSERT(index >= 0); Q_ASSERT(index >= 0);
Q_ASSERT(index < nativeIndexes.size()); Q_ASSERT(index < nativeIndexes.size());
@ -1001,7 +1001,7 @@ PathList TorrentImpl::actualFilePaths() const
return paths; return paths;
} }
QVector<DownloadPriority> TorrentImpl::filePriorities() const QList<DownloadPriority> TorrentImpl::filePriorities() const
{ {
return m_filePriorities; return m_filePriorities;
} }
@ -1317,7 +1317,7 @@ qlonglong TorrentImpl::eta() const
return (wantedSize() - completedSize()) / speedAverage.download; return (wantedSize() - completedSize()) / speedAverage.download;
} }
QVector<qreal> TorrentImpl::filesProgress() const QList<qreal> TorrentImpl::filesProgress() const
{ {
if (!hasMetadata()) if (!hasMetadata())
return {}; return {};
@ -1328,9 +1328,9 @@ QVector<qreal> TorrentImpl::filesProgress() const
return {}; return {};
if (m_completedFiles.count(true) == count) if (m_completedFiles.count(true) == count)
return QVector<qreal>(count, 1); return QList<qreal>(count, 1);
QVector<qreal> result; QList<qreal> result;
result.reserve(count); result.reserve(count);
for (int i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
{ {
@ -1445,12 +1445,12 @@ bool TorrentImpl::isLSDDisabled() const
return static_cast<bool>(m_nativeStatus.flags & lt::torrent_flags::disable_lsd); return static_cast<bool>(m_nativeStatus.flags & lt::torrent_flags::disable_lsd);
} }
QVector<PeerInfo> TorrentImpl::peers() const QList<PeerInfo> TorrentImpl::peers() const
{ {
std::vector<lt::peer_info> nativePeers; std::vector<lt::peer_info> nativePeers;
m_nativeHandle.get_peer_info(nativePeers); m_nativeHandle.get_peer_info(nativePeers);
QVector<PeerInfo> peers; QList<PeerInfo> peers;
peers.reserve(static_cast<decltype(peers)::size_type>(nativePeers.size())); peers.reserve(static_cast<decltype(peers)::size_type>(nativePeers.size()));
for (const lt::peer_info &peer : nativePeers) for (const lt::peer_info &peer : nativePeers)
@ -1477,7 +1477,7 @@ QBitArray TorrentImpl::downloadingPieces() const
return result; return result;
} }
QVector<int> TorrentImpl::pieceAvailability() const QList<int> TorrentImpl::pieceAvailability() const
{ {
std::vector<int> avail; std::vector<int> avail;
m_nativeHandle.piece_availability(avail); m_nativeHandle.piece_availability(avail);
@ -2113,7 +2113,7 @@ void TorrentImpl::handleSaveResumeDataAlert(const lt::save_resume_data_alert *p)
// URL seed list have been changed by libtorrent for some reason, so we need to update cached one. // URL seed list have been changed by libtorrent for some reason, so we need to update cached one.
// Unfortunately, URL seed list containing in "resume data" is generated according to different rules // Unfortunately, URL seed list containing in "resume data" is generated according to different rules
// than the list we usually cache, so we have to request it from the appropriate source. // than the list we usually cache, so we have to request it from the appropriate source.
fetchURLSeeds([this](const QVector<QUrl> &urlSeeds) { m_urlSeeds = urlSeeds; }); fetchURLSeeds([this](const QList<QUrl> &urlSeeds) { m_urlSeeds = urlSeeds; });
} }
if ((m_maintenanceJob == MaintenanceJob::HandleMetadata) && p->params.ti) if ((m_maintenanceJob == MaintenanceJob::HandleMetadata) && p->params.ti)
@ -2490,7 +2490,7 @@ void TorrentImpl::adjustStorageLocation()
void TorrentImpl::doRenameFile(const int index, const Path &path) void TorrentImpl::doRenameFile(const int index, const Path &path)
{ {
const QVector<lt::file_index_t> nativeIndexes = m_torrentInfo.nativeIndexes(); const QList<lt::file_index_t> nativeIndexes = m_torrentInfo.nativeIndexes();
Q_ASSERT(index >= 0); Q_ASSERT(index >= 0);
Q_ASSERT(index < nativeIndexes.size()); Q_ASSERT(index < nativeIndexes.size());
@ -2872,15 +2872,15 @@ nonstd::expected<void, QString> TorrentImpl::exportToFile(const Path &path) cons
return {}; return {};
} }
void TorrentImpl::fetchPeerInfo(std::function<void (QVector<PeerInfo>)> resultHandler) const void TorrentImpl::fetchPeerInfo(std::function<void (QList<PeerInfo>)> resultHandler) const
{ {
invokeAsync([nativeHandle = m_nativeHandle, allPieces = pieces()]() -> QVector<PeerInfo> invokeAsync([nativeHandle = m_nativeHandle, allPieces = pieces()]() -> QList<PeerInfo>
{ {
try try
{ {
std::vector<lt::peer_info> nativePeers; std::vector<lt::peer_info> nativePeers;
nativeHandle.get_peer_info(nativePeers); nativeHandle.get_peer_info(nativePeers);
QVector<PeerInfo> peers; QList<PeerInfo> peers;
peers.reserve(static_cast<decltype(peers)::size_type>(nativePeers.size())); peers.reserve(static_cast<decltype(peers)::size_type>(nativePeers.size()));
for (const lt::peer_info &peer : nativePeers) for (const lt::peer_info &peer : nativePeers)
peers.append(PeerInfo(peer, allPieces)); peers.append(PeerInfo(peer, allPieces));
@ -2893,14 +2893,14 @@ void TorrentImpl::fetchPeerInfo(std::function<void (QVector<PeerInfo>)> resultHa
, std::move(resultHandler)); , std::move(resultHandler));
} }
void TorrentImpl::fetchURLSeeds(std::function<void (QVector<QUrl>)> resultHandler) const void TorrentImpl::fetchURLSeeds(std::function<void (QList<QUrl>)> resultHandler) const
{ {
invokeAsync([nativeHandle = m_nativeHandle]() -> QVector<QUrl> invokeAsync([nativeHandle = m_nativeHandle]() -> QList<QUrl>
{ {
try try
{ {
const std::set<std::string> currentSeeds = nativeHandle.url_seeds(); const std::set<std::string> currentSeeds = nativeHandle.url_seeds();
QVector<QUrl> urlSeeds; QList<QUrl> urlSeeds;
urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(currentSeeds.size())); urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(currentSeeds.size()));
for (const std::string &urlSeed : currentSeeds) for (const std::string &urlSeed : currentSeeds)
urlSeeds.append(QString::fromStdString(urlSeed)); urlSeeds.append(QString::fromStdString(urlSeed));
@ -2913,15 +2913,15 @@ void TorrentImpl::fetchURLSeeds(std::function<void (QVector<QUrl>)> resultHandle
, std::move(resultHandler)); , std::move(resultHandler));
} }
void TorrentImpl::fetchPieceAvailability(std::function<void (QVector<int>)> resultHandler) const void TorrentImpl::fetchPieceAvailability(std::function<void (QList<int>)> resultHandler) const
{ {
invokeAsync([nativeHandle = m_nativeHandle]() -> QVector<int> invokeAsync([nativeHandle = m_nativeHandle]() -> QList<int>
{ {
try try
{ {
std::vector<int> piecesAvailability; std::vector<int> piecesAvailability;
nativeHandle.piece_availability(piecesAvailability); nativeHandle.piece_availability(piecesAvailability);
return QVector<int>(piecesAvailability.cbegin(), piecesAvailability.cend()); return QList<int>(piecesAvailability.cbegin(), piecesAvailability.cend());
} }
catch (const std::exception &) {} catch (const std::exception &) {}
@ -2955,9 +2955,9 @@ void TorrentImpl::fetchDownloadingPieces(std::function<void (QBitArray)> resultH
, std::move(resultHandler)); , std::move(resultHandler));
} }
void TorrentImpl::fetchAvailableFileFractions(std::function<void (QVector<qreal>)> resultHandler) const void TorrentImpl::fetchAvailableFileFractions(std::function<void (QList<qreal>)> resultHandler) const
{ {
invokeAsync([nativeHandle = m_nativeHandle, torrentInfo = m_torrentInfo]() -> QVector<qreal> invokeAsync([nativeHandle = m_nativeHandle, torrentInfo = m_torrentInfo]() -> QList<qreal>
{ {
if (!torrentInfo.isValid() || (torrentInfo.filesCount() <= 0)) if (!torrentInfo.isValid() || (torrentInfo.filesCount() <= 0))
return {}; return {};
@ -2969,9 +2969,9 @@ void TorrentImpl::fetchAvailableFileFractions(std::function<void (QVector<qreal>
const int filesCount = torrentInfo.filesCount(); const int filesCount = torrentInfo.filesCount();
// libtorrent returns empty array for seeding only torrents // libtorrent returns empty array for seeding only torrents
if (piecesAvailability.empty()) if (piecesAvailability.empty())
return QVector<qreal>(filesCount, -1); return QList<qreal>(filesCount, -1);
QVector<qreal> result; QList<qreal> result;
result.reserve(filesCount); result.reserve(filesCount);
for (int i = 0; i < filesCount; ++i) for (int i = 0; i < filesCount; ++i)
{ {
@ -2995,7 +2995,7 @@ void TorrentImpl::fetchAvailableFileFractions(std::function<void (QVector<qreal>
, std::move(resultHandler)); , std::move(resultHandler));
} }
void TorrentImpl::prioritizeFiles(const QVector<DownloadPriority> &priorities) void TorrentImpl::prioritizeFiles(const QList<DownloadPriority> &priorities)
{ {
if (!hasMetadata()) if (!hasMetadata())
return; return;
@ -3004,7 +3004,7 @@ void TorrentImpl::prioritizeFiles(const QVector<DownloadPriority> &priorities)
// Reset 'm_hasSeedStatus' if needed in order to react again to // Reset 'm_hasSeedStatus' if needed in order to react again to
// 'torrent_finished_alert' and eg show tray notifications // 'torrent_finished_alert' and eg show tray notifications
const QVector<DownloadPriority> oldPriorities = filePriorities(); const QList<DownloadPriority> oldPriorities = filePriorities();
for (int i = 0; i < oldPriorities.size(); ++i) for (int i = 0; i < oldPriorities.size(); ++i)
{ {
if ((oldPriorities[i] == DownloadPriority::Ignored) if ((oldPriorities[i] == DownloadPriority::Ignored)
@ -3032,18 +3032,18 @@ void TorrentImpl::prioritizeFiles(const QVector<DownloadPriority> &priorities)
manageActualFilePaths(); manageActualFilePaths();
} }
QVector<qreal> TorrentImpl::availableFileFractions() const QList<qreal> TorrentImpl::availableFileFractions() const
{ {
Q_ASSERT(hasMetadata()); Q_ASSERT(hasMetadata());
const int filesCount = this->filesCount(); const int filesCount = this->filesCount();
if (filesCount <= 0) return {}; if (filesCount <= 0) return {};
const QVector<int> piecesAvailability = pieceAvailability(); const QList<int> piecesAvailability = pieceAvailability();
// libtorrent returns empty array for seeding only torrents // libtorrent returns empty array for seeding only torrents
if (piecesAvailability.empty()) return QVector<qreal>(filesCount, -1); if (piecesAvailability.empty()) return QList<qreal>(filesCount, -1);
QVector<qreal> res; QList<qreal> res;
res.reserve(filesCount); res.reserve(filesCount);
for (int i = 0; i < filesCount; ++i) for (int i = 0; i < filesCount; ++i)
{ {

42
src/base/bittorrent/torrentimpl.h
View file

@ -41,11 +41,11 @@
#include <QBitArray> #include <QBitArray>
#include <QDateTime> #include <QDateTime>
#include <QHash> #include <QHash>
#include <QList>
#include <QMap> #include <QMap>
#include <QObject> #include <QObject>
#include <QQueue> #include <QQueue>
#include <QString> #include <QString>
#include <QVector>
#include "base/path.h" #include "base/path.h"
#include "base/tagset.h" #include "base/tagset.h"
@ -154,7 +154,7 @@ namespace BitTorrent
qlonglong fileSize(int index) const override; qlonglong fileSize(int index) const override;
PathList filePaths() const override; PathList filePaths() const override;
PathList actualFilePaths() const override; PathList actualFilePaths() const override;
QVector<DownloadPriority> filePriorities() const override; QList<DownloadPriority> filePriorities() const override;
TorrentInfo info() const override; TorrentInfo info() const override;
bool isFinished() const override; bool isFinished() const override;
@ -176,15 +176,15 @@ namespace BitTorrent
bool hasMissingFiles() const override; bool hasMissingFiles() const override;
bool hasError() const override; bool hasError() const override;
int queuePosition() const override; int queuePosition() const override;
QVector<TrackerEntryStatus> trackers() const override; QList<TrackerEntryStatus> trackers() const override;
QVector<QUrl> urlSeeds() const override; QList<QUrl> urlSeeds() const override;
QString error() const override; QString error() const override;
qlonglong totalDownload() const override; qlonglong totalDownload() const override;
qlonglong totalUpload() const override; qlonglong totalUpload() const override;
qlonglong activeTime() const override; qlonglong activeTime() const override;
qlonglong finishedTime() const override; qlonglong finishedTime() const override;
qlonglong eta() const override; qlonglong eta() const override;
QVector<qreal> filesProgress() const override; QList<qreal> filesProgress() const override;
int seedsCount() const override; int seedsCount() const override;
int peersCount() const override; int peersCount() const override;
int leechsCount() const override; int leechsCount() const override;
@ -202,10 +202,10 @@ namespace BitTorrent
bool isDHTDisabled() const override; bool isDHTDisabled() const override;
bool isPEXDisabled() const override; bool isPEXDisabled() const override;
bool isLSDDisabled() const override; bool isLSDDisabled() const override;
QVector<PeerInfo> peers() const override; QList<PeerInfo> peers() const override;
QBitArray pieces() const override; QBitArray pieces() const override;
QBitArray downloadingPieces() const override; QBitArray downloadingPieces() const override;
QVector<int> pieceAvailability() const override; QList<int> pieceAvailability() const override;
qreal distributedCopies() const override; qreal distributedCopies() const override;
qreal maxRatio() const override; qreal maxRatio() const override;
int maxSeedingTime() const override; int maxSeedingTime() const override;
@ -219,7 +219,7 @@ namespace BitTorrent
int connectionsCount() const override; int connectionsCount() const override;
int connectionsLimit() const override; int connectionsLimit() const override;
qlonglong nextAnnounce() const override; qlonglong nextAnnounce() const override;
QVector<qreal> availableFileFractions() const override; QList<qreal> availableFileFractions() const override;
void setName(const QString &name) override; void setName(const QString &name) override;
void setSequentialDownload(bool enable) override; void setSequentialDownload(bool enable) override;
@ -230,7 +230,7 @@ namespace BitTorrent
void forceDHTAnnounce() override; void forceDHTAnnounce() override;
void forceRecheck() override; void forceRecheck() override;
void renameFile(int index, const Path &path) override; void renameFile(int index, const Path &path) override;
void prioritizeFiles(const QVector<DownloadPriority> &priorities) override; void prioritizeFiles(const QList<DownloadPriority> &priorities) override;
void setUploadLimit(int limit) override; void setUploadLimit(int limit) override;
void setDownloadLimit(int limit) override; void setDownloadLimit(int limit) override;
void setSuperSeeding(bool enable) override; void setSuperSeeding(bool enable) override;
@ -238,11 +238,11 @@ namespace BitTorrent
void setPEXDisabled(bool disable) override; void setPEXDisabled(bool disable) override;
void setLSDDisabled(bool disable) override; void setLSDDisabled(bool disable) override;
void flushCache() const override; void flushCache() const override;
void addTrackers(QVector<TrackerEntry> trackers) override; void addTrackers(QList<TrackerEntry> trackers) override;
void removeTrackers(const QStringList &trackers) override; void removeTrackers(const QStringList &trackers) override;
void replaceTrackers(QVector<TrackerEntry> trackers) override; void replaceTrackers(QList<TrackerEntry> trackers) override;
void addUrlSeeds(const QVector<QUrl> &urlSeeds) override; void addUrlSeeds(const QList<QUrl> &urlSeeds) override;
void removeUrlSeeds(const QVector<QUrl> &urlSeeds) override; void removeUrlSeeds(const QList<QUrl> &urlSeeds) override;
bool connectPeer(const PeerAddress &peerAddress) override; bool connectPeer(const PeerAddress &peerAddress) override;
void clearPeers() override; void clearPeers() override;
void setMetadata(const TorrentInfo &torrentInfo) override; void setMetadata(const TorrentInfo &torrentInfo) override;
@ -257,11 +257,11 @@ namespace BitTorrent
nonstd::expected<QByteArray, QString> exportToBuffer() const override; nonstd::expected<QByteArray, QString> exportToBuffer() const override;
nonstd::expected<void, QString> exportToFile(const Path &path) const override; nonstd::expected<void, QString> exportToFile(const Path &path) const override;
void fetchPeerInfo(std::function<void (QVector<PeerInfo>)> resultHandler) const override; void fetchPeerInfo(std::function<void (QList<PeerInfo>)> resultHandler) const override;
void fetchURLSeeds(std::function<void (QVector<QUrl>)> resultHandler) const override; void fetchURLSeeds(std::function<void (QList<QUrl>)> resultHandler) const override;
void fetchPieceAvailability(std::function<void (QVector<int>)> resultHandler) const override; void fetchPieceAvailability(std::function<void (QList<int>)> resultHandler) const override;
void fetchDownloadingPieces(std::function<void (QBitArray)> resultHandler) const override; void fetchDownloadingPieces(std::function<void (QBitArray)> resultHandler) const override;
void fetchAvailableFileFractions(std::function<void (QVector<qreal>)> resultHandler) const override; void fetchAvailableFileFractions(std::function<void (QList<qreal>)> resultHandler) const override;
bool needSaveResumeData() const; bool needSaveResumeData() const;
@ -336,7 +336,7 @@ namespace BitTorrent
TorrentInfo m_torrentInfo; TorrentInfo m_torrentInfo;
PathList m_filePaths; PathList m_filePaths;
QHash<lt::file_index_t, int> m_indexMap; QHash<lt::file_index_t, int> m_indexMap;
QVector<DownloadPriority> m_filePriorities; QList<DownloadPriority> m_filePriorities;
QBitArray m_completedFiles; QBitArray m_completedFiles;
SpeedMonitor m_payloadRateMonitor; SpeedMonitor m_payloadRateMonitor;
@ -352,8 +352,8 @@ namespace BitTorrent
MaintenanceJob m_maintenanceJob = MaintenanceJob::None; MaintenanceJob m_maintenanceJob = MaintenanceJob::None;
QVector<TrackerEntryStatus> m_trackerEntryStatuses; QList<TrackerEntryStatus> m_trackerEntryStatuses;
QVector<QUrl> m_urlSeeds; QList<QUrl> m_urlSeeds;
FileErrorInfo m_lastFileError; FileErrorInfo m_lastFileError;
// Persistent data // Persistent data
@ -384,7 +384,7 @@ namespace BitTorrent
int m_uploadLimit = 0; int m_uploadLimit = 0;
QBitArray m_pieces; QBitArray m_pieces;
QVector<std::int64_t> m_filesProgress; QList<std::int64_t> m_filesProgress;
bool m_deferredRequestResumeDataInvoked = false; bool m_deferredRequestResumeDataInvoked = false;
}; };

20
src/base/bittorrent/torrentinfo.cpp
View file

@ -270,13 +270,13 @@ qlonglong TorrentInfo::fileOffset(const int index) const
return m_nativeInfo->orig_files().file_offset(m_nativeIndexes[index]); return m_nativeInfo->orig_files().file_offset(m_nativeIndexes[index]);
} }
QVector<TrackerEntry> TorrentInfo::trackers() const QList<TrackerEntry> TorrentInfo::trackers() const
{ {
if (!isValid()) return {}; if (!isValid()) return {};
const std::vector<lt::announce_entry> trackers = m_nativeInfo->trackers(); const std::vector<lt::announce_entry> trackers = m_nativeInfo->trackers();
QVector<TrackerEntry> ret; QList<TrackerEntry> ret;
ret.reserve(static_cast<decltype(ret)::size_type>(trackers.size())); ret.reserve(static_cast<decltype(ret)::size_type>(trackers.size()));
for (const lt::announce_entry &tracker : trackers) for (const lt::announce_entry &tracker : trackers)
ret.append({.url = QString::fromStdString(tracker.url), .tier = tracker.tier}); ret.append({.url = QString::fromStdString(tracker.url), .tier = tracker.tier});
@ -284,13 +284,13 @@ QVector<TrackerEntry> TorrentInfo::trackers() const
return ret; return ret;
} }
QVector<QUrl> TorrentInfo::urlSeeds() const QList<QUrl> TorrentInfo::urlSeeds() const
{ {
if (!isValid()) return {}; if (!isValid()) return {};
const std::vector<lt::web_seed_entry> &nativeWebSeeds = m_nativeInfo->web_seeds(); const std::vector<lt::web_seed_entry> &nativeWebSeeds = m_nativeInfo->web_seeds();
QVector<QUrl> urlSeeds; QList<QUrl> urlSeeds;
urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(nativeWebSeeds.size())); urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(nativeWebSeeds.size()));
for (const lt::web_seed_entry &webSeed : nativeWebSeeds) for (const lt::web_seed_entry &webSeed : nativeWebSeeds)
@ -320,7 +320,7 @@ QByteArray TorrentInfo::metadata() const
PathList TorrentInfo::filesForPiece(const int pieceIndex) const PathList TorrentInfo::filesForPiece(const int pieceIndex) const
{ {
// no checks here because fileIndicesForPiece() will return an empty list // no checks here because fileIndicesForPiece() will return an empty list
const QVector<int> fileIndices = fileIndicesForPiece(pieceIndex); const QList<int> fileIndices = fileIndicesForPiece(pieceIndex);
PathList res; PathList res;
res.reserve(fileIndices.size()); res.reserve(fileIndices.size());
@ -330,14 +330,14 @@ PathList TorrentInfo::filesForPiece(const int pieceIndex) const
return res; return res;
} }
QVector<int> TorrentInfo::fileIndicesForPiece(const int pieceIndex) const QList<int> TorrentInfo::fileIndicesForPiece(const int pieceIndex) const
{ {
if (!isValid() || (pieceIndex < 0) || (pieceIndex >= piecesCount())) if (!isValid() || (pieceIndex < 0) || (pieceIndex >= piecesCount()))
return {}; return {};
const std::vector<lt::file_slice> files = m_nativeInfo->map_block( const std::vector<lt::file_slice> files = m_nativeInfo->map_block(
lt::piece_index_t {pieceIndex}, 0, m_nativeInfo->piece_size(lt::piece_index_t {pieceIndex})); lt::piece_index_t {pieceIndex}, 0, m_nativeInfo->piece_size(lt::piece_index_t {pieceIndex}));
QVector<int> res; QList<int> res;
res.reserve(static_cast<decltype(res)::size_type>(files.size())); res.reserve(static_cast<decltype(res)::size_type>(files.size()));
for (const lt::file_slice &fileSlice : files) for (const lt::file_slice &fileSlice : files)
{ {
@ -349,13 +349,13 @@ QVector<int> TorrentInfo::fileIndicesForPiece(const int pieceIndex) const
return res; return res;
} }
QVector<QByteArray> TorrentInfo::pieceHashes() const QList<QByteArray> TorrentInfo::pieceHashes() const
{ {
if (!isValid()) if (!isValid())
return {}; return {};
const int count = piecesCount(); const int count = piecesCount();
QVector<QByteArray> hashes; QList<QByteArray> hashes;
hashes.reserve(count); hashes.reserve(count);
for (int i = 0; i < count; ++i) for (int i = 0; i < count; ++i)
@ -450,7 +450,7 @@ std::shared_ptr<lt::torrent_info> TorrentInfo::nativeInfo() const
return std::make_shared<lt::torrent_info>(*m_nativeInfo); return std::make_shared<lt::torrent_info>(*m_nativeInfo);
} }
QVector<lt::file_index_t> TorrentInfo::nativeIndexes() const QList<lt::file_index_t> TorrentInfo::nativeIndexes() const
{ {
return m_nativeIndexes; return m_nativeIndexes;
} }

14
src/base/bittorrent/torrentinfo.h
View file

@ -32,7 +32,7 @@
#include <QtContainerFwd> #include <QtContainerFwd>
#include <QCoreApplication> #include <QCoreApplication>
#include <QVector> #include <QList>
#include "base/3rdparty/expected.hpp" #include "base/3rdparty/expected.hpp"
#include "base/indexrange.h" #include "base/indexrange.h"
@ -80,12 +80,12 @@ namespace BitTorrent
PathList filePaths() const; PathList filePaths() const;
qlonglong fileSize(int index) const; qlonglong fileSize(int index) const;
qlonglong fileOffset(int index) const; qlonglong fileOffset(int index) const;
QVector<TrackerEntry> trackers() const; QList<TrackerEntry> trackers() const;
QVector<QUrl> urlSeeds() const; QList<QUrl> urlSeeds() const;
QByteArray metadata() const; QByteArray metadata() const;
PathList filesForPiece(int pieceIndex) const; PathList filesForPiece(int pieceIndex) const;
QVector<int> fileIndicesForPiece(int pieceIndex) const; QList<int> fileIndicesForPiece(int pieceIndex) const;
QVector<QByteArray> pieceHashes() const; QList<QByteArray> pieceHashes() const;
using PieceRange = IndexRange<int>; using PieceRange = IndexRange<int>;
// returns pair of the first and the last pieces into which // returns pair of the first and the last pieces into which
@ -96,7 +96,7 @@ namespace BitTorrent
bool matchesInfoHash(const InfoHash &otherInfoHash) const; bool matchesInfoHash(const InfoHash &otherInfoHash) const;
std::shared_ptr<lt::torrent_info> nativeInfo() const; std::shared_ptr<lt::torrent_info> nativeInfo() const;
QVector<lt::file_index_t> nativeIndexes() const; QList<lt::file_index_t> nativeIndexes() const;
private: private:
// returns file index or -1 if fileName is not found // returns file index or -1 if fileName is not found
@ -106,7 +106,7 @@ namespace BitTorrent
// internal indexes of files (payload only, excluding any .pad files) // internal indexes of files (payload only, excluding any .pad files)
// by which they are addressed in libtorrent // by which they are addressed in libtorrent
QVector<lt::file_index_t> m_nativeIndexes; QList<lt::file_index_t> m_nativeIndexes;
}; };
} }

4
src/base/http/types.h
View file

@ -30,8 +30,8 @@
#pragma once #pragma once
#include <QHostAddress> #include <QHostAddress>
#include <QList>
#include <QString> #include <QString>
#include <QVector>
#include "base/global.h" #include "base/global.h"
@ -109,7 +109,7 @@ namespace Http
HeaderMap headers; HeaderMap headers;
QHash<QString, QByteArray> query; QHash<QString, QByteArray> query;
QHash<QString, QString> posts; QHash<QString, QString> posts;
QVector<UploadedFile> files; QList<UploadedFile> files;
}; };
struct ResponseStatus struct ResponseStatus

10
src/base/logger.cpp
View file

@ -31,14 +31,14 @@
#include <algorithm> #include <algorithm>
#include <QDateTime> #include <QDateTime>
#include <QVector> #include <QList>
namespace namespace
{ {
template <typename T> template <typename T>
QVector<T> loadFromBuffer(const boost::circular_buffer_space_optimized<T> &src, const int offset = 0) QList<T> loadFromBuffer(const boost::circular_buffer_space_optimized<T> &src, const int offset = 0)
{ {
QVector<T> ret; QList<T> ret;
ret.reserve(static_cast<typename decltype(ret)::size_type>(src.size()) - offset); ret.reserve(static_cast<typename decltype(ret)::size_type>(src.size()) - offset);
std::copy((src.begin() + offset), src.end(), std::back_inserter(ret)); std::copy((src.begin() + offset), src.end(), std::back_inserter(ret));
return ret; return ret;
@ -90,7 +90,7 @@ void Logger::addPeer(const QString &ip, const bool blocked, const QString &reaso
emit newLogPeer(msg); emit newLogPeer(msg);
} }
QVector<Log::Msg> Logger::getMessages(const int lastKnownId) const QList<Log::Msg> Logger::getMessages(const int lastKnownId) const
{ {
const QReadLocker locker(&m_lock); const QReadLocker locker(&m_lock);
@ -106,7 +106,7 @@ QVector<Log::Msg> Logger::getMessages(const int lastKnownId) const
return loadFromBuffer(m_messages, (size - diff)); return loadFromBuffer(m_messages, (size - diff));
} }
QVector<Log::Peer> Logger::getPeers(const int lastKnownId) const QList<Log::Peer> Logger::getPeers(const int lastKnownId) const
{ {
const QReadLocker locker(&m_lock); const QReadLocker locker(&m_lock);

4
src/base/logger.h
View file

@ -81,8 +81,8 @@ public:
void addMessage(const QString &message, const Log::MsgType &type = Log::NORMAL); void addMessage(const QString &message, const Log::MsgType &type = Log::NORMAL);
void addPeer(const QString &ip, bool blocked, const QString &reason = {}); void addPeer(const QString &ip, bool blocked, const QString &reason = {});
QVector<Log::Msg> getMessages(int lastKnownId = -1) const; QList<Log::Msg> getMessages(int lastKnownId = -1) const;
QVector<Log::Peer> getPeers(int lastKnownId = -1) const; QList<Log::Peer> getPeers(int lastKnownId = -1) const;
signals: signals:
void newLogMessage(const Log::Msg &message); void newLogMessage(const Log::Msg &message);

4
src/base/preferences.cpp
View file

@ -673,11 +673,11 @@ void Preferences::setWebUIAuthSubnetWhitelistEnabled(const bool enabled)
setValue(u"Preferences/WebUI/AuthSubnetWhitelistEnabled"_s, enabled); setValue(u"Preferences/WebUI/AuthSubnetWhitelistEnabled"_s, enabled);
} }
QVector<Utils::Net::Subnet> Preferences::getWebUIAuthSubnetWhitelist() const QList<Utils::Net::Subnet> Preferences::getWebUIAuthSubnetWhitelist() const
{ {
const auto subnets = value<QStringList>(u"Preferences/WebUI/AuthSubnetWhitelist"_s); const auto subnets = value<QStringList>(u"Preferences/WebUI/AuthSubnetWhitelist"_s);
QVector<Utils::Net::Subnet> ret; QList<Utils::Net::Subnet> ret;
ret.reserve(subnets.size()); ret.reserve(subnets.size());
for (const QString &rawSubnet : subnets) for (const QString &rawSubnet : subnets)

2
src/base/preferences.h
View file

@ -185,7 +185,7 @@ public:
void setWebUILocalAuthEnabled(bool enabled); void setWebUILocalAuthEnabled(bool enabled);
bool isWebUIAuthSubnetWhitelistEnabled() const; bool isWebUIAuthSubnetWhitelistEnabled() const;
void setWebUIAuthSubnetWhitelistEnabled(bool enabled); void setWebUIAuthSubnetWhitelistEnabled(bool enabled);
QVector<Utils::Net::Subnet> getWebUIAuthSubnetWhitelist() const; QList<Utils::Net::Subnet> getWebUIAuthSubnetWhitelist() const;
void setWebUIAuthSubnetWhitelist(QStringList subnets); void setWebUIAuthSubnetWhitelist(QStringList subnets);
QString getWebUIUsername() const; QString getWebUIUsername() const;
void setWebUIUsername(const QString &username); void setWebUIUsername(const QString &username);

10
src/base/rss/feed_serializer.cpp
View file

@ -34,14 +34,14 @@
#include <QJsonArray> #include <QJsonArray>
#include <QJsonDocument> #include <QJsonDocument>
#include <QJsonObject> #include <QJsonObject>
#include <QVector> #include <QList>
#include "base/logger.h" #include "base/logger.h"
#include "base/path.h" #include "base/path.h"
#include "base/utils/io.h" #include "base/utils/io.h"
#include "rss_article.h" #include "rss_article.h"
const int ARTICLEDATALIST_TYPEID = qRegisterMetaType<QVector<QVariantHash>>(); const int ARTICLEDATALIST_TYPEID = qRegisterMetaType<QList<QVariantHash>>();
void RSS::Private::FeedSerializer::load(const Path &dataFileName, const QString &url) void RSS::Private::FeedSerializer::load(const Path &dataFileName, const QString &url)
{ {
@ -61,7 +61,7 @@ void RSS::Private::FeedSerializer::load(const Path &dataFileName, const QString
emit loadingFinished(loadArticles(readResult.value(), url)); emit loadingFinished(loadArticles(readResult.value(), url));
} }
void RSS::Private::FeedSerializer::store(const Path &dataFileName, const QVector<QVariantHash> &articlesData) void RSS::Private::FeedSerializer::store(const Path &dataFileName, const QList<QVariantHash> &articlesData)
{ {
QJsonArray arr; QJsonArray arr;
for (const QVariantHash &data : articlesData) for (const QVariantHash &data : articlesData)
@ -81,7 +81,7 @@ void RSS::Private::FeedSerializer::store(const Path &dataFileName, const QVector
} }
} }
QVector<QVariantHash> RSS::Private::FeedSerializer::loadArticles(const QByteArray &data, const QString &url) QList<QVariantHash> RSS::Private::FeedSerializer::loadArticles(const QByteArray &data, const QString &url)
{ {
QJsonParseError jsonError; QJsonParseError jsonError;
const QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &jsonError); const QJsonDocument jsonDoc = QJsonDocument::fromJson(data, &jsonError);
@ -98,7 +98,7 @@ QVector<QVariantHash> RSS::Private::FeedSerializer::loadArticles(const QByteArra
return {}; return {};
} }
QVector<QVariantHash> result; QList<QVariantHash> result;
const QJsonArray jsonArr = jsonDoc.array(); const QJsonArray jsonArr = jsonDoc.array();
result.reserve(jsonArr.size()); result.reserve(jsonArr.size());
for (int i = 0; i < jsonArr.size(); ++i) for (int i = 0; i < jsonArr.size(); ++i)

6
src/base/rss/feed_serializer.h
View file

@ -49,12 +49,12 @@ namespace RSS::Private
using QObject::QObject; using QObject::QObject;
void load(const Path &dataFileName, const QString &url); void load(const Path &dataFileName, const QString &url);
void store(const Path &dataFileName, const QVector<QVariantHash> &articlesData); void store(const Path &dataFileName, const QList<QVariantHash> &articlesData);
signals: signals:
void loadingFinished(const QVector<QVariantHash> &articles); void loadingFinished(const QList<QVariantHash> &articles);
private: private:
QVector<QVariantHash> loadArticles(const QByteArray &data, const QString &url); QList<QVariantHash> loadArticles(const QByteArray &data, const QString &url);
}; };
} }

6
src/base/rss/rss_autodownloader.cpp
View file

@ -35,11 +35,11 @@
#include <QJsonDocument> #include <QJsonDocument>
#include <QJsonObject> #include <QJsonObject>
#include <QJsonValue> #include <QJsonValue>
#include <QList>
#include <QThread> #include <QThread>
#include <QTimer> #include <QTimer>
#include <QUrl> #include <QUrl>
#include <QVariant> #include <QVariant>
#include <QVector>
#include "base/addtorrentmanager.h" #include "base/addtorrentmanager.h"
#include "base/asyncfilestorage.h" #include "base/asyncfilestorage.h"
@ -68,7 +68,7 @@ const QString RULES_FILE_NAME = u"download_rules.json"_s;
namespace namespace
{ {
QVector<RSS::AutoDownloadRule> rulesFromJSON(const QByteArray &jsonData) QList<RSS::AutoDownloadRule> rulesFromJSON(const QByteArray &jsonData)
{ {
QJsonParseError jsonError; QJsonParseError jsonError;
const QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData, &jsonError); const QJsonDocument jsonDoc = QJsonDocument::fromJson(jsonData, &jsonError);
@ -79,7 +79,7 @@ namespace
throw RSS::ParsingError(RSS::AutoDownloader::tr("Invalid data format.")); throw RSS::ParsingError(RSS::AutoDownloader::tr("Invalid data format."));
const QJsonObject jsonObj {jsonDoc.object()}; const QJsonObject jsonObj {jsonDoc.object()};
QVector<RSS::AutoDownloadRule> rules; QList<RSS::AutoDownloadRule> rules;
for (auto it = jsonObj.begin(); it != jsonObj.end(); ++it) for (auto it = jsonObj.begin(); it != jsonObj.end(); ++it)
{ {
const QJsonValue jsonVal {it.value()}; const QJsonValue jsonVal {it.value()};

8
src/base/rss/rss_feed.cpp
View file

@ -39,8 +39,8 @@
#include <QJsonDocument> #include <QJsonDocument>
#include <QJsonObject> #include <QJsonObject>
#include <QJsonValue> #include <QJsonValue>
#include <QList>
#include <QUrl> #include <QUrl>
#include <QVector>
#include "base/asyncfilestorage.h" #include "base/asyncfilestorage.h"
#include "base/global.h" #include "base/global.h"
@ -301,7 +301,7 @@ void Feed::store()
m_dirty = false; m_dirty = false;
m_savingTimer.stop(); m_savingTimer.stop();
QVector<QVariantHash> articlesData; QList<QVariantHash> articlesData;
articlesData.reserve(m_articles.size()); articlesData.reserve(m_articles.size());
for (Article *article :asConst(m_articles)) for (Article *article :asConst(m_articles))
@ -395,7 +395,7 @@ int Feed::updateArticles(const QList<QVariantHash> &loadedArticles)
return 0; return 0;
QDateTime dummyPubDate {QDateTime::currentDateTime()}; QDateTime dummyPubDate {QDateTime::currentDateTime()};
QVector<QVariantHash> newArticles; QList<QVariantHash> newArticles;
newArticles.reserve(loadedArticles.size()); newArticles.reserve(loadedArticles.size());
for (QVariantHash article : loadedArticles) for (QVariantHash article : loadedArticles)
{ {
@ -516,7 +516,7 @@ void Feed::handleArticleRead(Article *article)
storeDeferred(); storeDeferred();
} }
void Feed::handleArticleLoadFinished(QVector<QVariantHash> articles) void Feed::handleArticleLoadFinished(QList<QVariantHash> articles)
{ {
Q_ASSERT(m_articles.isEmpty()); Q_ASSERT(m_articles.isEmpty());
Q_ASSERT(m_unreadCount == 0); Q_ASSERT(m_unreadCount == 0);

2
src/base/rss/rss_feed.h
View file

@ -102,7 +102,7 @@ namespace RSS
void handleDownloadFinished(const Net::DownloadResult &result); void handleDownloadFinished(const Net::DownloadResult &result);
void handleParsingFinished(const Private::ParsingResult &result); void handleParsingFinished(const Private::ParsingResult &result);
void handleArticleRead(Article *article); void handleArticleRead(Article *article);
void handleArticleLoadFinished(QVector<QVariantHash> articles); void handleArticleLoadFinished(QList<QVariantHash> articles);
private: private:
void timerEvent(QTimerEvent *event) override; void timerEvent(QTimerEvent *event) override;

4
src/base/search/searchhandler.cpp
View file

@ -31,10 +31,10 @@
#include <chrono> #include <chrono>
#include <QList>
#include <QMetaObject> #include <QMetaObject>
#include <QProcess> #include <QProcess>
#include <QTimer> #include <QTimer>
#include <QVector>
#include "base/global.h" #include "base/global.h"
#include "base/path.h" #include "base/path.h"
@ -145,7 +145,7 @@ void SearchHandler::readSearchOutput()
lines.prepend(m_searchResultLineTruncated + lines.takeFirst()); lines.prepend(m_searchResultLineTruncated + lines.takeFirst());
m_searchResultLineTruncated = lines.takeLast().trimmed(); m_searchResultLineTruncated = lines.takeLast().trimmed();
QVector<SearchResult> searchResultList; QList<SearchResult> searchResultList;
searchResultList.reserve(lines.size()); searchResultList.reserve(lines.size());
for (const QByteArray &line : asConst(lines)) for (const QByteArray &line : asConst(lines))

2
src/base/search/searchhandler.h
View file

@ -75,7 +75,7 @@ public:
signals: signals:
void searchFinished(bool cancelled = false); void searchFinished(bool cancelled = false);
void searchFailed(); void searchFailed();
void newSearchResults(const QVector<SearchResult> &results); void newSearchResults(const QList<SearchResult> &results);
private: private:
void readSearchOutput(); void readSearchOutput();

3
src/base/utils/net.cpp
View file

@ -33,7 +33,6 @@
#include <QSslCertificate> #include <QSslCertificate>
#include <QSslKey> #include <QSslKey>
#include <QString> #include <QString>
#include <QVector>
#include "base/global.h" #include "base/global.h"
@ -62,7 +61,7 @@ namespace Utils
|| (addr == QHostAddress(u"::ffff:127.0.0.1"_s)); || (addr == QHostAddress(u"::ffff:127.0.0.1"_s));
} }
bool isIPInSubnets(const QHostAddress &addr, const QVector<Subnet> &subnets) bool isIPInSubnets(const QHostAddress &addr, const QList<Subnet> &subnets)
{ {
QHostAddress protocolEquivalentAddress; QHostAddress protocolEquivalentAddress;
bool addrConversionOk = false; bool addrConversionOk = false;

2
src/base/utils/net.h
View file

@ -46,7 +46,7 @@ namespace Utils::Net
bool isValidIP(const QString &ip); bool isValidIP(const QString &ip);
std::optional<Subnet> parseSubnet(const QString &subnetStr); std::optional<Subnet> parseSubnet(const QString &subnetStr);
bool isLoopbackAddress(const QHostAddress &addr); bool isLoopbackAddress(const QHostAddress &addr);
bool isIPInSubnets(const QHostAddress &addr, const QVector<Subnet> &subnets); bool isIPInSubnets(const QHostAddress &addr, const QList<Subnet> &subnets);
QString subnetToString(const Subnet &subnet); QString subnetToString(const Subnet &subnet);
QHostAddress canonicalIPv6Addr(const QHostAddress &addr); QHostAddress canonicalIPv6Addr(const QHostAddress &addr);

2
src/base/utils/password.cpp
View file

@ -34,8 +34,8 @@
#include <openssl/evp.h> #include <openssl/evp.h>
#include <QByteArray> #include <QByteArray>
#include <QList>
#include <QString> #include <QString>
#include <QVector>
#include "base/global.h" #include "base/global.h"
#include "bytearray.h" #include "bytearray.h"

2
src/base/utils/string.cpp
View file

@ -31,10 +31,10 @@
#include <cmath> #include <cmath>
#include <QList>
#include <QLocale> #include <QLocale>
#include <QRegularExpression> #include <QRegularExpression>
#include <QStringList> #include <QStringList>
#include <QVector>
// to send numbers instead of strings with suffixes // to send numbers instead of strings with suffixes
QString Utils::String::fromDouble(const double n, const int precision) QString Utils::String::fromDouble(const double n, const int precision)

26
src/gui/addnewtorrentdialog.cpp
View file

@ -38,6 +38,7 @@
#include <QDebug> #include <QDebug>
#include <QDir> #include <QDir>
#include <QFileDialog> #include <QFileDialog>
#include <QList>
#include <QMenu> #include <QMenu>
#include <QMessageBox> #include <QMessageBox>
#include <QPushButton> #include <QPushButton>
@ -46,7 +47,6 @@
#include <QSize> #include <QSize>
#include <QString> #include <QString>
#include <QUrl> #include <QUrl>
#include <QVector>
#include "base/bittorrent/addtorrentparams.h" #include "base/bittorrent/addtorrentparams.h"
#include "base/bittorrent/downloadpriority.h" #include "base/bittorrent/downloadpriority.h"
@ -143,7 +143,7 @@ class AddNewTorrentDialog::TorrentContentAdaptor final
{ {
public: public:
TorrentContentAdaptor(const BitTorrent::TorrentInfo &torrentInfo, PathList &filePaths TorrentContentAdaptor(const BitTorrent::TorrentInfo &torrentInfo, PathList &filePaths
, QVector<BitTorrent::DownloadPriority> &filePriorities, std::function<void ()> onFilePrioritiesChanged) , QList<BitTorrent::DownloadPriority> &filePriorities, std::function<void ()> onFilePrioritiesChanged)
: m_torrentInfo {torrentInfo} : m_torrentInfo {torrentInfo}
, m_filePaths {filePaths} , m_filePaths {filePaths}
, m_filePriorities {filePriorities} , m_filePriorities {filePriorities}
@ -227,29 +227,29 @@ public:
} }
} }
QVector<BitTorrent::DownloadPriority> filePriorities() const override QList<BitTorrent::DownloadPriority> filePriorities() const override
{ {
return m_filePriorities.isEmpty() return m_filePriorities.isEmpty()
? QVector<BitTorrent::DownloadPriority>(filesCount(), BitTorrent::DownloadPriority::Normal) ? QList<BitTorrent::DownloadPriority>(filesCount(), BitTorrent::DownloadPriority::Normal)
: m_filePriorities; : m_filePriorities;
} }
QVector<qreal> filesProgress() const override QList<qreal> filesProgress() const override
{ {
return QVector<qreal>(filesCount(), 0); return QList<qreal>(filesCount(), 0);
} }
QVector<qreal> availableFileFractions() const override QList<qreal> availableFileFractions() const override
{ {
return QVector<qreal>(filesCount(), 0); return QList<qreal>(filesCount(), 0);
} }
void fetchAvailableFileFractions(std::function<void (QVector<qreal>)> resultHandler) const override void fetchAvailableFileFractions(std::function<void (QList<qreal>)> resultHandler) const override
{ {
resultHandler(availableFileFractions()); resultHandler(availableFileFractions());
} }
void prioritizeFiles(const QVector<BitTorrent::DownloadPriority> &priorities) override void prioritizeFiles(const QList<BitTorrent::DownloadPriority> &priorities) override
{ {
Q_ASSERT(priorities.size() == filesCount()); Q_ASSERT(priorities.size() == filesCount());
m_filePriorities = priorities; m_filePriorities = priorities;
@ -274,7 +274,7 @@ public:
private: private:
const BitTorrent::TorrentInfo &m_torrentInfo; const BitTorrent::TorrentInfo &m_torrentInfo;
PathList &m_filePaths; PathList &m_filePaths;
QVector<BitTorrent::DownloadPriority> &m_filePriorities; QList<BitTorrent::DownloadPriority> &m_filePriorities;
std::function<void ()> m_onFilePrioritiesChanged; std::function<void ()> m_onFilePrioritiesChanged;
Path m_originalRootFolder; Path m_originalRootFolder;
BitTorrent::TorrentContentLayout m_currentContentLayout; BitTorrent::TorrentContentLayout m_currentContentLayout;
@ -594,7 +594,7 @@ void AddNewTorrentDialog::updateDiskSpaceLabel()
if (hasMetadata) if (hasMetadata)
{ {
const auto torrentInfo = *torrentDescr.info(); const auto torrentInfo = *torrentDescr.info();
const QVector<BitTorrent::DownloadPriority> &priorities = m_contentAdaptor->filePriorities(); const QList<BitTorrent::DownloadPriority> &priorities = m_contentAdaptor->filePriorities();
Q_ASSERT(priorities.size() == torrentInfo.filesCount()); Q_ASSERT(priorities.size() == torrentInfo.filesCount());
for (int i = 0; i < priorities.size(); ++i) for (int i = 0; i < priorities.size(); ++i)
{ {
@ -916,7 +916,7 @@ void AddNewTorrentDialog::setupTreeview()
if (BitTorrent::Session::instance()->isExcludedFileNamesEnabled()) if (BitTorrent::Session::instance()->isExcludedFileNamesEnabled())
{ {
// Check file name blacklist for torrents that are manually added // Check file name blacklist for torrents that are manually added
QVector<BitTorrent::DownloadPriority> priorities = m_contentAdaptor->filePriorities(); QList<BitTorrent::DownloadPriority> priorities = m_contentAdaptor->filePriorities();
BitTorrent::Session::instance()->applyFilenameFilter(m_contentAdaptor->filePaths(), priorities); BitTorrent::Session::instance()->applyFilenameFilter(m_contentAdaptor->filePaths(), priorities);
m_contentAdaptor->prioritizeFiles(priorities); m_contentAdaptor->prioritizeFiles(priorities);
} }

36
src/gui/filtermode.h Normal file
View file

@ -0,0 +1,36 @@
/*
* Bittorrent Client using Qt and libtorrent.
* Copyright (C) 2024 Vladimir Golovnev <glassez@yandex.ru>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* In addition, as a special exception, the copyright holders give permission to
* link this program with the OpenSSL project's "OpenSSL" library (or with
* modified versions of it that use the same license as the "OpenSSL" library),
* and distribute the linked executables. You must obey the GNU General Public
* License in all respects for all of the code used other than "OpenSSL". If you
* modify file(s), you may extend this exception to your version of the file(s),
* but you are not obligated to do so. If you do not wish to do so, delete this
* exception statement from your version.
*/
#pragma once
enum class FilterMode
{
PlainText = 0,
Wildcard = 1,
Regex = 2
};

8
src/gui/mainwindow.cpp
View file

@ -254,7 +254,7 @@ MainWindow::MainWindow(IGUIApplication *app, const WindowState initialState, con
#endif #endif
tr("Transfers")); tr("Transfers"));
// Filter types // Filter types
const QVector<TransferListModel::Column> filterTypes = {TransferListModel::Column::TR_NAME, TransferListModel::Column::TR_SAVE_PATH}; const QList<TransferListModel::Column> filterTypes = {TransferListModel::Column::TR_NAME, TransferListModel::Column::TR_SAVE_PATH};
for (const TransferListModel::Column type : filterTypes) for (const TransferListModel::Column type : filterTypes)
{ {
const QString typeName = m_transferListWidget->getSourceModel()->headerData(type, Qt::Horizontal, Qt::DisplayRole).value<QString>(); const QString typeName = m_transferListWidget->getSourceModel()->headerData(type, Qt::Horizontal, Qt::DisplayRole).value<QString>();
@ -1172,7 +1172,7 @@ void MainWindow::closeEvent(QCloseEvent *e)
} }
#endif // Q_OS_MACOS #endif // Q_OS_MACOS
const QVector<BitTorrent::Torrent *> allTorrents = BitTorrent::Session::instance()->torrents(); const QList<BitTorrent::Torrent *> allTorrents = BitTorrent::Session::instance()->torrents();
const bool hasActiveTorrents = std::any_of(allTorrents.cbegin(), allTorrents.cend(), [](BitTorrent::Torrent *torrent) const bool hasActiveTorrents = std::any_of(allTorrents.cbegin(), allTorrents.cend(), [](BitTorrent::Torrent *torrent)
{ {
return torrent->isActive(); return torrent->isActive();
@ -1523,7 +1523,7 @@ void MainWindow::loadSessionStats()
refreshWindowTitle(); refreshWindowTitle();
} }
void MainWindow::reloadTorrentStats(const QVector<BitTorrent::Torrent *> &torrents) void MainWindow::reloadTorrentStats(const QList<BitTorrent::Torrent *> &torrents)
{ {
if (currentTabWidget() == m_transferListWidget) if (currentTabWidget() == m_transferListWidget)
{ {
@ -1868,7 +1868,7 @@ void MainWindow::updatePowerManagementState() const
const bool preventFromSuspendWhenDownloading = pref->preventFromSuspendWhenDownloading(); const bool preventFromSuspendWhenDownloading = pref->preventFromSuspendWhenDownloading();
const bool preventFromSuspendWhenSeeding = pref->preventFromSuspendWhenSeeding(); const bool preventFromSuspendWhenSeeding = pref->preventFromSuspendWhenSeeding();
const QVector<BitTorrent::Torrent *> allTorrents = BitTorrent::Session::instance()->torrents(); const QList<BitTorrent::Torrent *> allTorrents = BitTorrent::Session::instance()->torrents();
const bool inhibitSuspend = std::any_of(allTorrents.cbegin(), allTorrents.cend(), [&](const BitTorrent::Torrent *torrent) const bool inhibitSuspend = std::any_of(allTorrents.cbegin(), allTorrents.cend(), [&](const BitTorrent::Torrent *torrent)
{ {
if (preventFromSuspendWhenDownloading && (!torrent->isFinished() && !torrent->isStopped() && !torrent->isErrored() && torrent->hasMetadata())) if (preventFromSuspendWhenDownloading && (!torrent->isFinished() && !torrent->isStopped() && !torrent->isErrored() && torrent->hasMetadata()))

2
src/gui/mainwindow.h
View file

@ -128,7 +128,7 @@ private slots:
void displayExecutionLogTab(); void displayExecutionLogTab();
void toggleFocusBetweenLineEdits(); void toggleFocusBetweenLineEdits();
void loadSessionStats(); void loadSessionStats();
void reloadTorrentStats(const QVector<BitTorrent::Torrent *> &torrents); void reloadTorrentStats(const QList<BitTorrent::Torrent *> &torrents);
void loadPreferences(); void loadPreferences();
void optionsSaved(); void optionsSaved();
void toggleAlternativeSpeeds(); void toggleAlternativeSpeeds();

2
src/gui/optionsdialog.cpp
View file

@ -1179,7 +1179,7 @@ void OptionsDialog::saveBittorrentTabOptions() const
session->setGlobalMaxRatio(getMaxRatio()); session->setGlobalMaxRatio(getMaxRatio());
session->setGlobalMaxSeedingMinutes(getMaxSeedingMinutes()); session->setGlobalMaxSeedingMinutes(getMaxSeedingMinutes());
session->setGlobalMaxInactiveSeedingMinutes(getMaxInactiveSeedingMinutes()); session->setGlobalMaxInactiveSeedingMinutes(getMaxInactiveSeedingMinutes());
const QVector<BitTorrent::ShareLimitAction> actIndex = const QList<BitTorrent::ShareLimitAction> actIndex =
{ {
BitTorrent::ShareLimitAction::Stop, BitTorrent::ShareLimitAction::Stop,
BitTorrent::ShareLimitAction::Remove, BitTorrent::ShareLimitAction::Remove,

2
src/gui/previewselectdialog.cpp
View file

@ -81,7 +81,7 @@ PreviewSelectDialog::PreviewSelectDialog(QWidget *parent, const BitTorrent::Torr
m_ui->previewList->setItemDelegate(listDelegate); m_ui->previewList->setItemDelegate(listDelegate);
// Fill list in // Fill list in
const QVector<qreal> fp = torrent->filesProgress(); const QList<qreal> fp = torrent->filesProgress();
for (int i = 0; i < torrent->filesCount(); ++i) for (int i = 0; i < torrent->filesCount(); ++i)
{ {
const Path filePath = torrent->filePath(i); const Path filePath = torrent->filePath(i);

10
src/gui/properties/downloadedpiecesbar.cpp
View file

@ -32,7 +32,7 @@
#include <cmath> #include <cmath>
#include <QDebug> #include <QDebug>
#include <QVector> #include <QList>
#include "base/global.h" #include "base/global.h"
@ -51,9 +51,9 @@ DownloadedPiecesBar::DownloadedPiecesBar(QWidget *parent)
{ {
} }
QVector<float> DownloadedPiecesBar::bitfieldToFloatVector(const QBitArray &vecin, int reqSize) QList<float> DownloadedPiecesBar::bitfieldToFloatVector(const QBitArray &vecin, int reqSize)
{ {
QVector<float> result(reqSize, 0.0); QList<float> result(reqSize, 0.0);
if (vecin.isEmpty()) return result; if (vecin.isEmpty()) return result;
const float ratio = vecin.size() / static_cast<float>(reqSize); const float ratio = vecin.size() / static_cast<float>(reqSize);
@ -145,8 +145,8 @@ bool DownloadedPiecesBar::updateImage(QImage &image)
return true; return true;
} }
QVector<float> scaledPieces = bitfieldToFloatVector(m_pieces, image2.width()); QList<float> scaledPieces = bitfieldToFloatVector(m_pieces, image2.width());
QVector<float> scaledPiecesDl = bitfieldToFloatVector(m_downloadedPieces, image2.width()); QList<float> scaledPiecesDl = bitfieldToFloatVector(m_downloadedPieces, image2.width());
// filling image // filling image
for (int x = 0; x < scaledPieces.size(); ++x) for (int x = 0; x < scaledPieces.size(); ++x)

2
src/gui/properties/downloadedpiecesbar.h
View file

@ -51,7 +51,7 @@ public:
private: private:
// scale bitfield vector to float vector // scale bitfield vector to float vector
QVector<float> bitfieldToFloatVector(const QBitArray &vecin, int reqSize); QList<float> bitfieldToFloatVector(const QBitArray &vecin, int reqSize);
bool updateImage(QImage &image) override; bool updateImage(QImage &image) override;
QString simpleToolTipText() const override; QString simpleToolTipText() const override;

8
src/gui/properties/peerlistwidget.cpp
View file

@ -35,6 +35,7 @@
#include <QClipboard> #include <QClipboard>
#include <QHeaderView> #include <QHeaderView>
#include <QHostAddress> #include <QHostAddress>
#include <QList>
#include <QMenu> #include <QMenu>
#include <QMessageBox> #include <QMessageBox>
#include <QPointer> #include <QPointer>
@ -42,7 +43,6 @@
#include <QShortcut> #include <QShortcut>
#include <QSortFilterProxyModel> #include <QSortFilterProxyModel>
#include <QStandardItemModel> #include <QStandardItemModel>
#include <QVector>
#include <QWheelEvent> #include <QWheelEvent>
#include "base/bittorrent/peeraddress.h" #include "base/bittorrent/peeraddress.h"
@ -290,7 +290,7 @@ void PeerListWidget::showPeerListMenu()
QAction *addNewPeer = menu->addAction(UIThemeManager::instance()->getIcon(u"peers-add"_s), tr("Add peers...") QAction *addNewPeer = menu->addAction(UIThemeManager::instance()->getIcon(u"peers-add"_s), tr("Add peers...")
, this, [this, torrent]() , this, [this, torrent]()
{ {
const QVector<BitTorrent::PeerAddress> peersList = PeersAdditionDialog::askForPeers(this); const QList<BitTorrent::PeerAddress> peersList = PeersAdditionDialog::askForPeers(this);
const int peerCount = std::count_if(peersList.cbegin(), peersList.cend(), [torrent](const BitTorrent::PeerAddress &peer) const int peerCount = std::count_if(peersList.cbegin(), peersList.cend(), [torrent](const BitTorrent::PeerAddress &peer)
{ {
return torrent->connectPeer(peer); return torrent->connectPeer(peer);
@ -335,7 +335,7 @@ void PeerListWidget::banSelectedPeers()
// Store selected rows first as selected peers may disconnect // Store selected rows first as selected peers may disconnect
const QModelIndexList selectedIndexes = selectionModel()->selectedRows(); const QModelIndexList selectedIndexes = selectionModel()->selectedRows();
QVector<QString> selectedIPs; QList<QString> selectedIPs;
selectedIPs.reserve(selectedIndexes.size()); selectedIPs.reserve(selectedIndexes.size());
for (const QModelIndex &index : selectedIndexes) for (const QModelIndex &index : selectedIndexes)
@ -405,7 +405,7 @@ void PeerListWidget::loadPeers(const BitTorrent::Torrent *torrent)
return; return;
using TorrentPtr = QPointer<const BitTorrent::Torrent>; using TorrentPtr = QPointer<const BitTorrent::Torrent>;
torrent->fetchPeerInfo([this, torrent = TorrentPtr(torrent)](const QVector<BitTorrent::PeerInfo> &peers) torrent->fetchPeerInfo([this, torrent = TorrentPtr(torrent)](const QList<BitTorrent::PeerInfo> &peers)
{ {
if (torrent != m_properties->getCurrentTorrent()) if (torrent != m_properties->getCurrentTorrent())
return; return;

2
src/gui/properties/peersadditiondialog.cpp
View file

@ -50,7 +50,7 @@ PeersAdditionDialog::~PeersAdditionDialog()
delete m_ui; delete m_ui;
} }
QVector<BitTorrent::PeerAddress> PeersAdditionDialog::askForPeers(QWidget *parent) QList<BitTorrent::PeerAddress> PeersAdditionDialog::askForPeers(QWidget *parent)
{ {
PeersAdditionDialog dlg(parent); PeersAdditionDialog dlg(parent);
dlg.exec(); dlg.exec();

6
src/gui/properties/peersadditiondialog.h
View file

@ -29,7 +29,7 @@
#pragma once #pragma once
#include <QDialog> #include <QDialog>
#include <QVector> #include <QList>
#include "base/bittorrent/peerinfo.h" #include "base/bittorrent/peerinfo.h"
@ -47,12 +47,12 @@ public:
PeersAdditionDialog(QWidget *parent); PeersAdditionDialog(QWidget *parent);
~PeersAdditionDialog(); ~PeersAdditionDialog();
static QVector<BitTorrent::PeerAddress> askForPeers(QWidget *parent); static QList<BitTorrent::PeerAddress> askForPeers(QWidget *parent);
protected slots: protected slots:
void validateInput(); void validateInput();
private: private:
Ui::PeersAdditionDialog *m_ui = nullptr; Ui::PeersAdditionDialog *m_ui = nullptr;
QVector<BitTorrent::PeerAddress> m_peersList; QList<BitTorrent::PeerAddress> m_peersList;
}; };

8
src/gui/properties/pieceavailabilitybar.cpp
View file

@ -40,9 +40,9 @@ PieceAvailabilityBar::PieceAvailabilityBar(QWidget *parent)
{ {
} }
QVector<float> PieceAvailabilityBar::intToFloatVector(const QVector<int> &vecin, int reqSize) QList<float> PieceAvailabilityBar::intToFloatVector(const QList<int> &vecin, int reqSize)
{ {
QVector<float> result(reqSize, 0.0); QList<float> result(reqSize, 0.0);
if (vecin.isEmpty()) return result; if (vecin.isEmpty()) return result;
const float ratio = static_cast<float>(vecin.size()) / reqSize; const float ratio = static_cast<float>(vecin.size()) / reqSize;
@ -142,7 +142,7 @@ bool PieceAvailabilityBar::updateImage(QImage &image)
return true; return true;
} }
QVector<float> scaledPieces = intToFloatVector(m_pieces, image2.width()); QList<float> scaledPieces = intToFloatVector(m_pieces, image2.width());
// filling image // filling image
for (int x = 0; x < scaledPieces.size(); ++x) for (int x = 0; x < scaledPieces.size(); ++x)
@ -154,7 +154,7 @@ bool PieceAvailabilityBar::updateImage(QImage &image)
return true; return true;
} }
void PieceAvailabilityBar::setAvailability(const QVector<int> &avail) void PieceAvailabilityBar::setAvailability(const QList<int> &avail)
{ {
m_pieces = avail; m_pieces = avail;

6
src/gui/properties/pieceavailabilitybar.h
View file

@ -40,7 +40,7 @@ class PieceAvailabilityBar final : public PiecesBar
public: public:
PieceAvailabilityBar(QWidget *parent); PieceAvailabilityBar(QWidget *parent);
void setAvailability(const QVector<int> &avail); void setAvailability(const QList<int> &avail);
// PiecesBar interface // PiecesBar interface
void clear() override; void clear() override;
@ -51,8 +51,8 @@ private:
// last used int vector, uses to better resize redraw // last used int vector, uses to better resize redraw
// TODO: make a diff pieces to new pieces and update only changed pixels, speedup when update > 20x faster // TODO: make a diff pieces to new pieces and update only changed pixels, speedup when update > 20x faster
QVector<int> m_pieces; QList<int> m_pieces;
// scale int vector to float vector // scale int vector to float vector
QVector<float> intToFloatVector(const QVector<int> &vecin, int reqSize); QList<float> intToFloatVector(const QList<int> &vecin, int reqSize);
}; };

8
src/gui/properties/piecesbar.cpp
View file

@ -222,7 +222,7 @@ QColor PiecesBar::colorBoxBorderColor() const
return palette().color(QPalette::ToolTipText); return palette().color(QPalette::ToolTipText);
} }
const QVector<QRgb> &PiecesBar::pieceColors() const const QList<QRgb> &PiecesBar::pieceColors() const
{ {
return m_pieceColors; return m_pieceColors;
} }
@ -261,7 +261,7 @@ void PiecesBar::showToolTip(const QHelpEvent *e)
{ {
const PieceIndexToImagePos transform {torrentInfo, m_image}; const PieceIndexToImagePos transform {torrentInfo, m_image};
const int pieceIndex = transform.pieceIndex(imagePos); const int pieceIndex = transform.pieceIndex(imagePos);
const QVector<int> fileIndexes = torrentInfo.fileIndicesForPiece(pieceIndex); const QList<int> fileIndexes = torrentInfo.fileIndicesForPiece(pieceIndex);
QString tooltipTitle; QString tooltipTitle;
if (fileIndexes.count() > 1) if (fileIndexes.count() > 1)
@ -305,7 +305,7 @@ void PiecesBar::highlightFile(int imagePos)
PieceIndexToImagePos transform {torrentInfo, m_image}; PieceIndexToImagePos transform {torrentInfo, m_image};
int pieceIndex = transform.pieceIndex(imagePos); int pieceIndex = transform.pieceIndex(imagePos);
QVector<int> fileIndices {torrentInfo.fileIndicesForPiece(pieceIndex)}; QList<int> fileIndices {torrentInfo.fileIndicesForPiece(pieceIndex)};
if (fileIndices.count() == 1) if (fileIndices.count() == 1)
{ {
BitTorrent::TorrentInfo::PieceRange filePieces = torrentInfo.filePieces(fileIndices.first()); BitTorrent::TorrentInfo::PieceRange filePieces = torrentInfo.filePieces(fileIndices.first());
@ -327,7 +327,7 @@ void PiecesBar::highlightFile(int imagePos)
void PiecesBar::updatePieceColors() void PiecesBar::updatePieceColors()
{ {
m_pieceColors = QVector<QRgb>(256); m_pieceColors = QList<QRgb>(256);
for (int i = 0; i < 256; ++i) for (int i = 0; i < 256; ++i)
{ {
float ratio = (i / 255.0); float ratio = (i / 255.0);

4
src/gui/properties/piecesbar.h
View file

@ -70,7 +70,7 @@ protected:
QColor borderColor() const; QColor borderColor() const;
QColor pieceColor() const; QColor pieceColor() const;
QColor colorBoxBorderColor() const; QColor colorBoxBorderColor() const;
const QVector<QRgb> &pieceColors() const; const QList<QRgb> &pieceColors() const;
// mix two colors by light model, ratio <0, 1> // mix two colors by light model, ratio <0, 1>
static QRgb mixTwoColors(QRgb rgb1, QRgb rgb2, float ratio); static QRgb mixTwoColors(QRgb rgb1, QRgb rgb2, float ratio);
@ -91,7 +91,7 @@ private:
const BitTorrent::Torrent *m_torrent = nullptr; const BitTorrent::Torrent *m_torrent = nullptr;
QImage m_image; QImage m_image;
// buffered 256 levels gradient from bg_color to piece_color // buffered 256 levels gradient from bg_color to piece_color
QVector<QRgb> m_pieceColors; QList<QRgb> m_pieceColors;
bool m_hovered = false; bool m_hovered = false;
QRect m_highlightedRegion; // part of the bar can be highlighted; this rectangle is in the same frame as m_image QRect m_highlightedRegion; // part of the bar can be highlighted; this rectangle is in the same frame as m_image
}; };

6
src/gui/properties/propertieswidget.cpp
View file

@ -471,7 +471,7 @@ void PropertiesWidget::loadDynamicData()
{ {
// Pieces availability // Pieces availability
showPiecesAvailability(true); showPiecesAvailability(true);
m_torrent->fetchPieceAvailability([this, torrent = TorrentPtr(m_torrent)](const QVector<int> &pieceAvailability) m_torrent->fetchPieceAvailability([this, torrent = TorrentPtr(m_torrent)](const QList<int> &pieceAvailability)
{ {
if (torrent == m_torrent) if (torrent == m_torrent)
m_piecesAvailability->setAvailability(pieceAvailability); m_piecesAvailability->setAvailability(pieceAvailability);
@ -517,7 +517,7 @@ void PropertiesWidget::loadUrlSeeds()
return; return;
using TorrentPtr = QPointer<BitTorrent::Torrent>; using TorrentPtr = QPointer<BitTorrent::Torrent>;
m_torrent->fetchURLSeeds([this, torrent = TorrentPtr(m_torrent)](const QVector<QUrl> &urlSeeds) m_torrent->fetchURLSeeds([this, torrent = TorrentPtr(m_torrent)](const QList<QUrl> &urlSeeds)
{ {
if (torrent != m_torrent) if (torrent != m_torrent)
return; return;
@ -620,7 +620,7 @@ void PropertiesWidget::deleteSelectedUrlSeeds()
const QList<QListWidgetItem *> selectedItems = m_ui->listWebSeeds->selectedItems(); const QList<QListWidgetItem *> selectedItems = m_ui->listWebSeeds->selectedItems();
if (selectedItems.isEmpty()) return; if (selectedItems.isEmpty()) return;
QVector<QUrl> urlSeeds; QList<QUrl> urlSeeds;
urlSeeds.reserve(selectedItems.size()); urlSeeds.reserve(selectedItems.size());
for (const QListWidgetItem *item : selectedItems) for (const QListWidgetItem *item : selectedItems)

4
src/gui/properties/speedplotview.cpp
View file

@ -292,7 +292,7 @@ void SpeedPlotView::paintEvent(QPaintEvent *)
rect.adjust(0, fontMetrics.height(), 0, 0); // Add top padding for top speed text rect.adjust(0, fontMetrics.height(), 0, 0); // Add top padding for top speed text
// draw Y axis speed labels // draw Y axis speed labels
const QVector<QString> speedLabels = const QList<QString> speedLabels =
{ {
formatLabel(niceScale.arg, niceScale.unit), formatLabel(niceScale.arg, niceScale.unit),
formatLabel((0.75 * niceScale.arg), niceScale.unit), formatLabel((0.75 * niceScale.arg), niceScale.unit),
@ -358,7 +358,7 @@ void SpeedPlotView::paintEvent(QPaintEvent *)
if (!m_properties[static_cast<GraphID>(id)].enable) if (!m_properties[static_cast<GraphID>(id)].enable)
continue; continue;
QVector<QPoint> points; QList<QPoint> points;
milliseconds duration {0}; milliseconds duration {0};
for (int i = static_cast<int>(queue.size()) - 1; i >= 0; --i) for (int i = static_cast<int>(queue.size()) - 1; i >= 0; --i)

4
src/gui/search/pluginselectdialog.cpp
View file

@ -249,9 +249,9 @@ void PluginSelectDialog::setRowColor(const int row, const QString &color)
} }
} }
QVector<QTreeWidgetItem*> PluginSelectDialog::findItemsWithUrl(const QString &url) QList<QTreeWidgetItem*> PluginSelectDialog::findItemsWithUrl(const QString &url)
{ {
QVector<QTreeWidgetItem*> res; QList<QTreeWidgetItem*> res;
res.reserve(m_ui->pluginsTree->topLevelItemCount()); res.reserve(m_ui->pluginsTree->topLevelItemCount());
for (int i = 0; i < m_ui->pluginsTree->topLevelItemCount(); ++i) for (int i = 0; i < m_ui->pluginsTree->topLevelItemCount(); ++i)

2
src/gui/search/pluginselectdialog.h
View file

@ -57,7 +57,7 @@ public:
explicit PluginSelectDialog(SearchPluginManager *pluginManager, QWidget *parent = nullptr); explicit PluginSelectDialog(SearchPluginManager *pluginManager, QWidget *parent = nullptr);
~PluginSelectDialog() override; ~PluginSelectDialog() override;
QVector<QTreeWidgetItem*> findItemsWithUrl(const QString &url); QList<QTreeWidgetItem*> findItemsWithUrl(const QString &url);
QTreeWidgetItem *findItemWithID(const QString &id); QTreeWidgetItem *findItemWithID(const QString &id);
protected: protected:

2
src/gui/search/searchjobwidget.cpp
View file

@ -508,7 +508,7 @@ void SearchJobWidget::searchFailed()
setStatus(Status::Error); setStatus(Status::Error);
} }
void SearchJobWidget::appendSearchResults(const QVector<SearchResult> &results) void SearchJobWidget::appendSearchResults(const QList<SearchResult> &results)
{ {
for (const SearchResult &result : results) for (const SearchResult &result : results)
{ {

2
src/gui/search/searchjobwidget.h
View file

@ -105,7 +105,7 @@ private:
void onItemDoubleClicked(const QModelIndex &index); void onItemDoubleClicked(const QModelIndex &index);
void searchFinished(bool cancelled); void searchFinished(bool cancelled);
void searchFailed(); void searchFailed();
void appendSearchResults(const QVector<SearchResult> &results); void appendSearchResults(const QList<SearchResult> &results);
void updateResultsCount(); void updateResultsCount();
void setStatus(Status value); void setStatus(Status value);
void downloadTorrent(const QModelIndex &rowIndex, AddTorrentOption option = AddTorrentOption::Default); void downloadTorrent(const QModelIndex &rowIndex, AddTorrentOption option = AddTorrentOption::Default);

6
src/gui/search/searchwidget.cpp
View file

@ -40,13 +40,13 @@
#include <QDebug> #include <QDebug>
#include <QEvent> #include <QEvent>
#include <QList>
#include <QMessageBox> #include <QMessageBox>
#include <QMenu> #include <QMenu>
#include <QMouseEvent> #include <QMouseEvent>
#include <QObject> #include <QObject>
#include <QRegularExpression> #include <QRegularExpression>
#include <QShortcut> #include <QShortcut>
#include <QVector>
#include "base/global.h" #include "base/global.h"
#include "base/search/searchhandler.h" #include "base/search/searchhandler.h"
@ -184,7 +184,7 @@ void SearchWidget::fillCatCombobox()
m_ui->comboCategory->addItem(SearchPluginManager::categoryFullName(u"all"_s), u"all"_s); m_ui->comboCategory->addItem(SearchPluginManager::categoryFullName(u"all"_s), u"all"_s);
using QStrPair = std::pair<QString, QString>; using QStrPair = std::pair<QString, QString>;
QVector<QStrPair> tmpList; QList<QStrPair> tmpList;
for (const QString &cat : asConst(SearchPluginManager::instance()->getPluginCategories(selectedPlugin()))) for (const QString &cat : asConst(SearchPluginManager::instance()->getPluginCategories(selectedPlugin())))
tmpList << std::make_pair(SearchPluginManager::categoryFullName(cat), cat); tmpList << std::make_pair(SearchPluginManager::categoryFullName(cat), cat);
std::sort(tmpList.begin(), tmpList.end(), [](const QStrPair &l, const QStrPair &r) { return (QString::localeAwareCompare(l.first, r.first) < 0); }); std::sort(tmpList.begin(), tmpList.end(), [](const QStrPair &l, const QStrPair &r) { return (QString::localeAwareCompare(l.first, r.first) < 0); });
@ -207,7 +207,7 @@ void SearchWidget::fillPluginComboBox()
m_ui->selectPlugin->addItem(tr("Select..."), u"multi"_s); m_ui->selectPlugin->addItem(tr("Select..."), u"multi"_s);
using QStrPair = std::pair<QString, QString>; using QStrPair = std::pair<QString, QString>;
QVector<QStrPair> tmpList; QList<QStrPair> tmpList;
for (const QString &name : asConst(SearchPluginManager::instance()->enabledPlugins())) for (const QString &name : asConst(SearchPluginManager::instance()->enabledPlugins()))
tmpList << std::make_pair(SearchPluginManager::instance()->pluginFullName(name), name); tmpList << std::make_pair(SearchPluginManager::instance()->pluginFullName(name), name);
std::sort(tmpList.begin(), tmpList.end(), [](const QStrPair &l, const QStrPair &r) { return (l.first < r.first); } ); std::sort(tmpList.begin(), tmpList.end(), [](const QStrPair &l, const QStrPair &r) { return (l.first < r.first); } );

22
src/gui/torrentcontentmodel.cpp
View file

@ -163,7 +163,7 @@ namespace
TorrentContentModel::TorrentContentModel(QObject *parent) TorrentContentModel::TorrentContentModel(QObject *parent)
: QAbstractItemModel(parent) : QAbstractItemModel(parent)
, m_rootItem(new TorrentContentModelFolder(QVector<QString>({ tr("Name"), tr("Total Size"), tr("Progress"), tr("Download Priority"), tr("Remaining"), tr("Availability") }))) , m_rootItem(new TorrentContentModelFolder(QList<QString>({ tr("Name"), tr("Total Size"), tr("Progress"), tr("Download Priority"), tr("Remaining"), tr("Availability") })))
#if defined(Q_OS_WIN) #if defined(Q_OS_WIN)
, m_fileIconProvider {new QFileIconProvider} , m_fileIconProvider {new QFileIconProvider}
#elif defined(Q_OS_MACOS) #elif defined(Q_OS_MACOS)
@ -185,7 +185,7 @@ void TorrentContentModel::updateFilesProgress()
{ {
Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata()); Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata());
const QVector<qreal> &filesProgress = m_contentHandler->filesProgress(); const QList<qreal> &filesProgress = m_contentHandler->filesProgress();
Q_ASSERT(m_filesIndex.size() == filesProgress.size()); Q_ASSERT(m_filesIndex.size() == filesProgress.size());
// XXX: Why is this necessary? // XXX: Why is this necessary?
if (m_filesIndex.size() != filesProgress.size()) [[unlikely]] if (m_filesIndex.size() != filesProgress.size()) [[unlikely]]
@ -202,7 +202,7 @@ void TorrentContentModel::updateFilesPriorities()
{ {
Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata()); Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata());
const QVector<BitTorrent::DownloadPriority> fprio = m_contentHandler->filePriorities(); const QList<BitTorrent::DownloadPriority> fprio = m_contentHandler->filePriorities();
Q_ASSERT(m_filesIndex.size() == fprio.size()); Q_ASSERT(m_filesIndex.size() == fprio.size());
// XXX: Why is this necessary? // XXX: Why is this necessary?
if (m_filesIndex.size() != fprio.size()) if (m_filesIndex.size() != fprio.size())
@ -217,7 +217,7 @@ void TorrentContentModel::updateFilesAvailability()
Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata()); Q_ASSERT(m_contentHandler && m_contentHandler->hasMetadata());
using HandlerPtr = QPointer<BitTorrent::TorrentContentHandler>; using HandlerPtr = QPointer<BitTorrent::TorrentContentHandler>;
m_contentHandler->fetchAvailableFileFractions([this, handler = HandlerPtr(m_contentHandler)](const QVector<qreal> &availableFileFractions) m_contentHandler->fetchAvailableFileFractions([this, handler = HandlerPtr(m_contentHandler)](const QList<qreal> &availableFileFractions)
{ {
if (handler != m_contentHandler) if (handler != m_contentHandler)
return; return;
@ -250,7 +250,7 @@ bool TorrentContentModel::setItemPriority(const QModelIndex &index, BitTorrent::
m_rootItem->recalculateProgress(); m_rootItem->recalculateProgress();
m_rootItem->recalculateAvailability(); m_rootItem->recalculateAvailability();
const QVector<ColumnInterval> columns = const QList<ColumnInterval> columns =
{ {
{TorrentContentModelItem::COL_NAME, TorrentContentModelItem::COL_NAME}, {TorrentContentModelItem::COL_NAME, TorrentContentModelItem::COL_NAME},
{TorrentContentModelItem::COL_PRIO, TorrentContentModelItem::COL_PRIO} {TorrentContentModelItem::COL_PRIO, TorrentContentModelItem::COL_PRIO}
@ -260,9 +260,9 @@ bool TorrentContentModel::setItemPriority(const QModelIndex &index, BitTorrent::
return true; return true;
} }
QVector<BitTorrent::DownloadPriority> TorrentContentModel::getFilePriorities() const QList<BitTorrent::DownloadPriority> TorrentContentModel::getFilePriorities() const
{ {
QVector<BitTorrent::DownloadPriority> prio; QList<BitTorrent::DownloadPriority> prio;
prio.reserve(m_filesIndex.size()); prio.reserve(m_filesIndex.size());
for (const TorrentContentModelFile *file : asConst(m_filesIndex)) for (const TorrentContentModelFile *file : asConst(m_filesIndex))
prio.push_back(file->priority()); prio.push_back(file->priority());
@ -523,7 +523,7 @@ void TorrentContentModel::populate()
m_filesIndex.reserve(filesCount); m_filesIndex.reserve(filesCount);
QHash<TorrentContentModelFolder *, QHash<QString, TorrentContentModelFolder *>> folderMap; QHash<TorrentContentModelFolder *, QHash<QString, TorrentContentModelFolder *>> folderMap;
QVector<QString> lastParentPath; QList<QString> lastParentPath;
TorrentContentModelFolder *lastParent = m_rootItem; TorrentContentModelFolder *lastParent = m_rootItem;
// Iterate over files // Iterate over files
for (int i = 0; i < filesCount; ++i) for (int i = 0; i < filesCount; ++i)
@ -602,7 +602,7 @@ void TorrentContentModel::refresh()
updateFilesPriorities(); updateFilesPriorities();
updateFilesAvailability(); updateFilesAvailability();
const QVector<ColumnInterval> columns = const QList<ColumnInterval> columns =
{ {
{TorrentContentModelItem::COL_NAME, TorrentContentModelItem::COL_NAME}, {TorrentContentModelItem::COL_NAME, TorrentContentModelItem::COL_NAME},
{TorrentContentModelItem::COL_PROGRESS, TorrentContentModelItem::COL_PROGRESS}, {TorrentContentModelItem::COL_PROGRESS, TorrentContentModelItem::COL_PROGRESS},
@ -619,7 +619,7 @@ void TorrentContentModel::refresh()
} }
} }
void TorrentContentModel::notifySubtreeUpdated(const QModelIndex &index, const QVector<ColumnInterval> &columns) void TorrentContentModel::notifySubtreeUpdated(const QModelIndex &index, const QList<ColumnInterval> &columns)
{ {
// For best performance, `columns` entries should be arranged from left to right // For best performance, `columns` entries should be arranged from left to right
@ -639,7 +639,7 @@ void TorrentContentModel::notifySubtreeUpdated(const QModelIndex &index, const Q
} }
// propagate down the model // propagate down the model
QVector<QModelIndex> parentIndexes; QList<QModelIndex> parentIndexes;
if (hasChildren(index)) if (hasChildren(index))
parentIndexes.push_back(index); parentIndexes.push_back(index);

8
src/gui/torrentcontentmodel.h
View file

@ -30,7 +30,7 @@
#pragma once #pragma once
#include <QAbstractItemModel> #include <QAbstractItemModel>
#include <QVector> #include <QList>
#include "base/indexrange.h" #include "base/indexrange.h"
#include "base/pathfwd.h" #include "base/pathfwd.h"
@ -66,7 +66,7 @@ public:
void refresh(); void refresh();
QVector<BitTorrent::DownloadPriority> getFilePriorities() const; QList<BitTorrent::DownloadPriority> getFilePriorities() const;
TorrentContentModelItem::ItemType itemType(const QModelIndex &index) const; TorrentContentModelItem::ItemType itemType(const QModelIndex &index) const;
int getFileIndex(const QModelIndex &index) const; int getFileIndex(const QModelIndex &index) const;
Path getItemPath(const QModelIndex &index) const; Path getItemPath(const QModelIndex &index) const;
@ -91,10 +91,10 @@ private:
void updateFilesPriorities(); void updateFilesPriorities();
void updateFilesAvailability(); void updateFilesAvailability();
bool setItemPriority(const QModelIndex &index, BitTorrent::DownloadPriority priority); bool setItemPriority(const QModelIndex &index, BitTorrent::DownloadPriority priority);
void notifySubtreeUpdated(const QModelIndex &index, const QVector<ColumnInterval> &columns); void notifySubtreeUpdated(const QModelIndex &index, const QList<ColumnInterval> &columns);
BitTorrent::TorrentContentHandler *m_contentHandler = nullptr; BitTorrent::TorrentContentHandler *m_contentHandler = nullptr;
TorrentContentModelFolder *m_rootItem = nullptr; TorrentContentModelFolder *m_rootItem = nullptr;
QVector<TorrentContentModelFile *> m_filesIndex; QList<TorrentContentModelFile *> m_filesIndex;
QFileIconProvider *m_fileIconProvider = nullptr; QFileIconProvider *m_fileIconProvider = nullptr;
}; };

4
src/gui/torrentcontentmodelfolder.cpp
View file

@ -39,7 +39,7 @@ TorrentContentModelFolder::TorrentContentModelFolder(const QString &name, Torren
m_name = name; m_name = name;
} }
TorrentContentModelFolder::TorrentContentModelFolder(const QVector<QString> &data) TorrentContentModelFolder::TorrentContentModelFolder(const QList<QString> &data)
: TorrentContentModelItem(nullptr) : TorrentContentModelItem(nullptr)
{ {
Q_ASSERT(data.size() == NB_COL); Q_ASSERT(data.size() == NB_COL);
@ -63,7 +63,7 @@ void TorrentContentModelFolder::deleteAllChildren()
m_childItems.clear(); m_childItems.clear();
} }
const QVector<TorrentContentModelItem *> &TorrentContentModelFolder::children() const const QList<TorrentContentModelItem *> &TorrentContentModelFolder::children() const
{ {
return m_childItems; return m_childItems;
} }

6
src/gui/torrentcontentmodelfolder.h
View file

@ -42,7 +42,7 @@ public:
TorrentContentModelFolder(const QString &name, TorrentContentModelFolder *parent); TorrentContentModelFolder(const QString &name, TorrentContentModelFolder *parent);
// Invisible root item constructor // Invisible root item constructor
explicit TorrentContentModelFolder(const QVector<QString> &data); explicit TorrentContentModelFolder(const QList<QString> &data);
~TorrentContentModelFolder() override; ~TorrentContentModelFolder() override;
@ -56,11 +56,11 @@ public:
void setPriority(BitTorrent::DownloadPriority newPriority, bool updateParent = true) override; void setPriority(BitTorrent::DownloadPriority newPriority, bool updateParent = true) override;
void deleteAllChildren(); void deleteAllChildren();
const QVector<TorrentContentModelItem*> &children() const; const QList<TorrentContentModelItem*> &children() const;
void appendChild(TorrentContentModelItem *item); void appendChild(TorrentContentModelItem *item);
TorrentContentModelItem *child(int row) const; TorrentContentModelItem *child(int row) const;
int childCount() const; int childCount() const;
private: private:
QVector<TorrentContentModelItem *> m_childItems; QList<TorrentContentModelItem *> m_childItems;
}; };

4
src/gui/torrentcontentmodelitem.h
View file

@ -29,7 +29,7 @@
#pragma once #pragma once
#include <QCoreApplication> #include <QCoreApplication>
#include <QVector> #include <QList>
#include "base/bittorrent/downloadpriority.h" #include "base/bittorrent/downloadpriority.h"
@ -86,7 +86,7 @@ public:
protected: protected:
TorrentContentModelFolder *m_parentItem = nullptr; TorrentContentModelFolder *m_parentItem = nullptr;
// Root item members // Root item members
QVector<QString> m_itemData; QList<QString> m_itemData;
// Non-root item members // Non-root item members
QString m_name; QString m_name;
qulonglong m_size = 0; qulonglong m_size = 0;

2
src/gui/torrentoptionsdialog.cpp
View file

@ -58,7 +58,7 @@ namespace
} }
} }
TorrentOptionsDialog::TorrentOptionsDialog(QWidget *parent, const QVector<BitTorrent::Torrent *> &torrents) TorrentOptionsDialog::TorrentOptionsDialog(QWidget *parent, const QList<BitTorrent::Torrent *> &torrents)
: QDialog {parent} : QDialog {parent}
, m_ui {new Ui::TorrentOptionsDialog} , m_ui {new Ui::TorrentOptionsDialog}
, m_storeDialogSize {SETTINGS_KEY(u"Size"_s)} , m_storeDialogSize {SETTINGS_KEY(u"Size"_s)}

4
src/gui/torrentoptionsdialog.h
View file

@ -58,7 +58,7 @@ class TorrentOptionsDialog final : public QDialog
Q_DISABLE_COPY_MOVE(TorrentOptionsDialog) Q_DISABLE_COPY_MOVE(TorrentOptionsDialog)
public: public:
explicit TorrentOptionsDialog(QWidget *parent, const QVector<BitTorrent::Torrent *> &torrents); explicit TorrentOptionsDialog(QWidget *parent, const QList<BitTorrent::Torrent *> &torrents);
~TorrentOptionsDialog() override; ~TorrentOptionsDialog() override;
public slots: public slots:
@ -73,7 +73,7 @@ private slots:
void handleDownSpeedLimitChanged(); void handleDownSpeedLimitChanged();
private: private:
QVector<BitTorrent::TorrentID> m_torrentIDs; QList<BitTorrent::TorrentID> m_torrentIDs;
Ui::TorrentOptionsDialog *m_ui = nullptr; Ui::TorrentOptionsDialog *m_ui = nullptr;
SettingValue<QSize> m_storeDialogSize; SettingValue<QSize> m_storeDialogSize;
QStringList m_categories; QStringList m_categories;

6
src/gui/trackerentriesdialog.cpp
View file

@ -31,7 +31,7 @@
#include <algorithm> #include <algorithm>
#include <QHash> #include <QHash>
#include <QVector> #include <QList>
#include "base/bittorrent/trackerentry.h" #include "base/bittorrent/trackerentry.h"
#include "ui_trackerentriesdialog.h" #include "ui_trackerentriesdialog.h"
@ -59,7 +59,7 @@ TrackerEntriesDialog::~TrackerEntriesDialog()
delete m_ui; delete m_ui;
} }
void TrackerEntriesDialog::setTrackers(const QVector<BitTorrent::TrackerEntry> &trackers) void TrackerEntriesDialog::setTrackers(const QList<BitTorrent::TrackerEntry> &trackers)
{ {
int maxTier = -1; int maxTier = -1;
QHash<int, QString> tiers; // <tier, tracker URLs> QHash<int, QString> tiers; // <tier, tracker URLs>
@ -78,7 +78,7 @@ void TrackerEntriesDialog::setTrackers(const QVector<BitTorrent::TrackerEntry> &
m_ui->plainTextEdit->setPlainText(text); m_ui->plainTextEdit->setPlainText(text);
} }
QVector<BitTorrent::TrackerEntry> TrackerEntriesDialog::trackers() const QList<BitTorrent::TrackerEntry> TrackerEntriesDialog::trackers() const
{ {
return BitTorrent::parseTrackerEntries(m_ui->plainTextEdit->toPlainText()); return BitTorrent::parseTrackerEntries(m_ui->plainTextEdit->toPlainText());
} }

4
src/gui/trackerentriesdialog.h
View file

@ -52,8 +52,8 @@ public:
explicit TrackerEntriesDialog(QWidget *parent); explicit TrackerEntriesDialog(QWidget *parent);
~TrackerEntriesDialog() override; ~TrackerEntriesDialog() override;
void setTrackers(const QVector<BitTorrent::TrackerEntry> &trackers); void setTrackers(const QList<BitTorrent::TrackerEntry> &trackers);
QVector<BitTorrent::TrackerEntry> trackers() const; QList<BitTorrent::TrackerEntry> trackers() const;
private: private:
void saveSettings(); void saveSettings();

2
src/gui/trackerlist/trackerlistwidget.cpp
View file

@ -35,6 +35,7 @@
#include <QColor> #include <QColor>
#include <QDebug> #include <QDebug>
#include <QHeaderView> #include <QHeaderView>
#include <QList>
#include <QLocale> #include <QLocale>
#include <QMenu> #include <QMenu>
#include <QMessageBox> #include <QMessageBox>
@ -42,7 +43,6 @@
#include <QStringList> #include <QStringList>
#include <QTreeWidgetItem> #include <QTreeWidgetItem>
#include <QUrl> #include <QUrl>
#include <QVector>
#include <QWheelEvent> #include <QWheelEvent>
#include "base/bittorrent/session.h" #include "base/bittorrent/session.h"

6
src/gui/trackersadditiondialog.cpp
View file

@ -29,10 +29,10 @@
#include "trackersadditiondialog.h" #include "trackersadditiondialog.h"
#include <QList>
#include <QMessageBox> #include <QMessageBox>
#include <QSize> #include <QSize>
#include <QStringView> #include <QStringView>
#include <QVector>
#include "base/bittorrent/torrent.h" #include "base/bittorrent/torrent.h"
#include "base/bittorrent/trackerentry.h" #include "base/bittorrent/trackerentry.h"
@ -76,10 +76,10 @@ TrackersAdditionDialog::~TrackersAdditionDialog()
void TrackersAdditionDialog::onAccepted() const void TrackersAdditionDialog::onAccepted() const
{ {
const QVector<BitTorrent::TrackerEntryStatus> currentTrackers = m_torrent->trackers(); const QList<BitTorrent::TrackerEntryStatus> currentTrackers = m_torrent->trackers();
const int baseTier = !currentTrackers.isEmpty() ? (currentTrackers.last().tier + 1) : 0; const int baseTier = !currentTrackers.isEmpty() ? (currentTrackers.last().tier + 1) : 0;
QVector<BitTorrent::TrackerEntry> entries = BitTorrent::parseTrackerEntries(m_ui->textEditTrackersList->toPlainText()); QList<BitTorrent::TrackerEntry> entries = BitTorrent::parseTrackerEntries(m_ui->textEditTrackersList->toPlainText());
for (BitTorrent::TrackerEntry &entry : entries) for (BitTorrent::TrackerEntry &entry : entries)
entry.tier = Utils::Number::clampingAdd(entry.tier, baseTier); entry.tier = Utils::Number::clampingAdd(entry.tier, baseTier);

2
src/gui/transferlistfilters/basefilterwidget.h
View file

@ -55,7 +55,7 @@ public slots:
private slots: private slots:
virtual void showMenu() = 0; virtual void showMenu() = 0;
virtual void applyFilter(int row) = 0; virtual void applyFilter(int row) = 0;
virtual void handleTorrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents) = 0; virtual void handleTorrentsLoaded(const QList<BitTorrent::Torrent *> &torrents) = 0;
virtual void torrentAboutToBeDeleted(BitTorrent::Torrent *) = 0; virtual void torrentAboutToBeDeleted(BitTorrent::Torrent *) = 0;
private: private:

2
src/gui/transferlistfilters/categoryfiltermodel.cpp
View file

@ -350,7 +350,7 @@ void CategoryFilterModel::categoryRemoved(const QString &categoryName)
} }
} }
void CategoryFilterModel::torrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents) void CategoryFilterModel::torrentsLoaded(const QList<BitTorrent::Torrent *> &torrents)
{ {
for (const BitTorrent::Torrent *torrent : torrents) for (const BitTorrent::Torrent *torrent : torrents)
{ {

2
src/gui/transferlistfilters/categoryfiltermodel.h
View file

@ -62,7 +62,7 @@ public:
private slots: private slots:
void categoryAdded(const QString &categoryName); void categoryAdded(const QString &categoryName);
void categoryRemoved(const QString &categoryName); void categoryRemoved(const QString &categoryName);
void torrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents); void torrentsLoaded(const QList<BitTorrent::Torrent *> &torrents);
void torrentAboutToBeRemoved(BitTorrent::Torrent *torrent); void torrentAboutToBeRemoved(BitTorrent::Torrent *torrent);
void torrentCategoryChanged(BitTorrent::Torrent *torrent, const QString &oldCategory); void torrentCategoryChanged(BitTorrent::Torrent *torrent, const QString &oldCategory);
void subcategoriesSupportChanged(); void subcategoriesSupportChanged();

6
src/gui/transferlistfilters/statusfilterwidget.cpp
View file

@ -86,7 +86,7 @@ StatusFilterWidget::StatusFilterWidget(QWidget *parent, TransferListWidget *tran
errored->setData(Qt::DisplayRole, tr("Errored (0)")); errored->setData(Qt::DisplayRole, tr("Errored (0)"));
errored->setData(Qt::DecorationRole, UIThemeManager::instance()->getIcon(u"error"_s)); errored->setData(Qt::DecorationRole, UIThemeManager::instance()->getIcon(u"error"_s));
const QVector<BitTorrent::Torrent *> torrents = BitTorrent::Session::instance()->torrents(); const QList<BitTorrent::Torrent *> torrents = BitTorrent::Session::instance()->torrents();
update(torrents); update(torrents);
connect(BitTorrent::Session::instance(), &BitTorrent::Session::torrentsUpdated connect(BitTorrent::Session::instance(), &BitTorrent::Session::torrentsUpdated
, this, &StatusFilterWidget::update); , this, &StatusFilterWidget::update);
@ -199,7 +199,7 @@ void StatusFilterWidget::hideZeroItems()
setCurrentRow(TorrentFilter::All, QItemSelectionModel::SelectCurrent); setCurrentRow(TorrentFilter::All, QItemSelectionModel::SelectCurrent);
} }
void StatusFilterWidget::update(const QVector<BitTorrent::Torrent *> &torrents) void StatusFilterWidget::update(const QList<BitTorrent::Torrent *> &torrents)
{ {
for (const BitTorrent::Torrent *torrent : torrents) for (const BitTorrent::Torrent *torrent : torrents)
updateTorrentStatus(torrent); updateTorrentStatus(torrent);
@ -233,7 +233,7 @@ void StatusFilterWidget::applyFilter(int row)
transferList()->applyStatusFilter(row); transferList()->applyStatusFilter(row);
} }
void StatusFilterWidget::handleTorrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents) void StatusFilterWidget::handleTorrentsLoaded(const QList<BitTorrent::Torrent *> &torrents)
{ {
for (const BitTorrent::Torrent *torrent : torrents) for (const BitTorrent::Torrent *torrent : torrents)
updateTorrentStatus(torrent); updateTorrentStatus(torrent);

4
src/gui/transferlistfilters/statusfilterwidget.h
View file

@ -53,12 +53,12 @@ private:
// No need to redeclare them here as slots. // No need to redeclare them here as slots.
void showMenu() override; void showMenu() override;
void applyFilter(int row) override; void applyFilter(int row) override;
void handleTorrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents) override; void handleTorrentsLoaded(const QList<BitTorrent::Torrent *> &torrents) override;
void torrentAboutToBeDeleted(BitTorrent::Torrent *) override; void torrentAboutToBeDeleted(BitTorrent::Torrent *) override;
void configure(); void configure();
void update(const QVector<BitTorrent::Torrent *> &torrents); void update(const QList<BitTorrent::Torrent *> &torrents);
void updateTorrentStatus(const BitTorrent::Torrent *torrent); void updateTorrentStatus(const BitTorrent::Torrent *torrent);
void updateTexts(); void updateTexts();
void hideZeroItems(); void hideZeroItems();

10
src/gui/transferlistfilters/tagfiltermodel.cpp
View file

@ -30,7 +30,7 @@
#include "tagfiltermodel.h" #include "tagfiltermodel.h"
#include <QIcon> #include <QIcon>
#include <QVector> #include <QList>
#include "base/bittorrent/session.h" #include "base/bittorrent/session.h"
#include "base/global.h" #include "base/global.h"
@ -236,13 +236,13 @@ void TagFilterModel::torrentTagRemoved(BitTorrent::Torrent *const torrent, const
emit dataChanged(i, i); emit dataChanged(i, i);
} }
void TagFilterModel::torrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents) void TagFilterModel::torrentsLoaded(const QList<BitTorrent::Torrent *> &torrents)
{ {
for (const BitTorrent::Torrent *torrent : torrents) for (const BitTorrent::Torrent *torrent : torrents)
{ {
allTagsItem()->increaseTorrentsCount(); allTagsItem()->increaseTorrentsCount();
const QVector<TagModelItem *> items = findItems(torrent->tags()); const QList<TagModelItem *> items = findItems(torrent->tags());
if (items.isEmpty()) if (items.isEmpty())
untaggedItem()->increaseTorrentsCount(); untaggedItem()->increaseTorrentsCount();
@ -339,9 +339,9 @@ TagModelItem *TagFilterModel::findItem(const Tag &tag)
return &m_tagItems[row]; return &m_tagItems[row];
} }
QVector<TagModelItem *> TagFilterModel::findItems(const TagSet &tags) QList<TagModelItem *> TagFilterModel::findItems(const TagSet &tags)
{ {
QVector<TagModelItem *> items; QList<TagModelItem *> items;
items.reserve(tags.count()); items.reserve(tags.count());
for (const Tag &tag : tags) for (const Tag &tag : tags)
{ {

4
src/gui/transferlistfilters/tagfiltermodel.h
View file

@ -64,7 +64,7 @@ private slots:
void tagRemoved(const Tag &tag); void tagRemoved(const Tag &tag);
void torrentTagAdded(BitTorrent::Torrent *torrent, const Tag &tag); void torrentTagAdded(BitTorrent::Torrent *torrent, const Tag &tag);
void torrentTagRemoved(BitTorrent::Torrent *, const Tag &tag); void torrentTagRemoved(BitTorrent::Torrent *, const Tag &tag);
void torrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents); void torrentsLoaded(const QList<BitTorrent::Torrent *> &torrents);
void torrentAboutToBeRemoved(BitTorrent::Torrent *torrent); void torrentAboutToBeRemoved(BitTorrent::Torrent *torrent);
private: private:
@ -74,7 +74,7 @@ private:
bool isValidRow(int row) const; bool isValidRow(int row) const;
int findRow(const Tag &tag) const; int findRow(const Tag &tag) const;
TagModelItem *findItem(const Tag &tag); TagModelItem *findItem(const Tag &tag);
QVector<TagModelItem *> findItems(const TagSet &tags); QList<TagModelItem *> findItems(const TagSet &tags);
TagModelItem *allTagsItem(); TagModelItem *allTagsItem();
TagModelItem *untaggedItem(); TagModelItem *untaggedItem();

14
src/gui/transferlistfilters/trackersfilterwidget.cpp
View file

@ -155,7 +155,7 @@ TrackersFilterWidget::~TrackersFilterWidget()
Utils::Fs::removeFile(iconPath); Utils::Fs::removeFile(iconPath);
} }
void TrackersFilterWidget::addTrackers(const BitTorrent::Torrent *torrent, const QVector<BitTorrent::TrackerEntry> &trackers) void TrackersFilterWidget::addTrackers(const BitTorrent::Torrent *torrent, const QList<BitTorrent::TrackerEntry> &trackers)
{ {
const BitTorrent::TorrentID torrentID = torrent->id(); const BitTorrent::TorrentID torrentID = torrent->id();
@ -204,7 +204,7 @@ void TrackersFilterWidget::refreshTrackers(const BitTorrent::Torrent *torrent)
return false; return false;
}); });
const QVector<BitTorrent::TrackerEntryStatus> trackers = torrent->trackers(); const QList<BitTorrent::TrackerEntryStatus> trackers = torrent->trackers();
if (trackers.isEmpty()) if (trackers.isEmpty())
{ {
addItems(NULL_HOST, {torrentID}); addItems(NULL_HOST, {torrentID});
@ -228,7 +228,7 @@ void TrackersFilterWidget::refreshTrackers(const BitTorrent::Torrent *torrent)
updateGeometry(); updateGeometry();
} }
void TrackersFilterWidget::addItems(const QString &trackerURL, const QVector<BitTorrent::TorrentID> &torrents) void TrackersFilterWidget::addItems(const QString &trackerURL, const QList<BitTorrent::TorrentID> &torrents)
{ {
const QString host = getHost(trackerURL); const QString host = getHost(trackerURL);
auto trackersIt = m_trackers.find(host); auto trackersIt = m_trackers.find(host);
@ -587,13 +587,13 @@ void TrackersFilterWidget::applyFilter(const int row)
transferList()->applyTrackerFilter(getTorrentIDs(row)); transferList()->applyTrackerFilter(getTorrentIDs(row));
} }
void TrackersFilterWidget::handleTorrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents) void TrackersFilterWidget::handleTorrentsLoaded(const QList<BitTorrent::Torrent *> &torrents)
{ {
QHash<QString, QVector<BitTorrent::TorrentID>> torrentsPerTracker; QHash<QString, QList<BitTorrent::TorrentID>> torrentsPerTracker;
for (const BitTorrent::Torrent *torrent : torrents) for (const BitTorrent::Torrent *torrent : torrents)
{ {
const BitTorrent::TorrentID torrentID = torrent->id(); const BitTorrent::TorrentID torrentID = torrent->id();
const QVector<BitTorrent::TrackerEntryStatus> trackers = torrent->trackers(); const QList<BitTorrent::TrackerEntryStatus> trackers = torrent->trackers();
for (const BitTorrent::TrackerEntryStatus &tracker : trackers) for (const BitTorrent::TrackerEntryStatus &tracker : trackers)
torrentsPerTracker[tracker.url].append(torrentID); torrentsPerTracker[tracker.url].append(torrentID);
@ -614,7 +614,7 @@ void TrackersFilterWidget::handleTorrentsLoaded(const QVector<BitTorrent::Torren
void TrackersFilterWidget::torrentAboutToBeDeleted(BitTorrent::Torrent *const torrent) void TrackersFilterWidget::torrentAboutToBeDeleted(BitTorrent::Torrent *const torrent)
{ {
const BitTorrent::TorrentID torrentID = torrent->id(); const BitTorrent::TorrentID torrentID = torrent->id();
const QVector<BitTorrent::TrackerEntryStatus> trackers = torrent->trackers(); const QList<BitTorrent::TrackerEntryStatus> trackers = torrent->trackers();
for (const BitTorrent::TrackerEntryStatus &tracker : trackers) for (const BitTorrent::TrackerEntryStatus &tracker : trackers)
removeItem(tracker.url, torrentID); removeItem(tracker.url, torrentID);

6
src/gui/transferlistfilters/trackersfilterwidget.h
View file

@ -57,7 +57,7 @@ public:
TrackersFilterWidget(QWidget *parent, TransferListWidget *transferList, bool downloadFavicon); TrackersFilterWidget(QWidget *parent, TransferListWidget *transferList, bool downloadFavicon);
~TrackersFilterWidget() override; ~TrackersFilterWidget() override;
void addTrackers(const BitTorrent::Torrent *torrent, const QVector<BitTorrent::TrackerEntry> &trackers); void addTrackers(const BitTorrent::Torrent *torrent, const QList<BitTorrent::TrackerEntry> &trackers);
void removeTrackers(const BitTorrent::Torrent *torrent, const QStringList &trackers); void removeTrackers(const BitTorrent::Torrent *torrent, const QStringList &trackers);
void refreshTrackers(const BitTorrent::Torrent *torrent); void refreshTrackers(const BitTorrent::Torrent *torrent);
void handleTrackerStatusesUpdated(const BitTorrent::Torrent *torrent void handleTrackerStatusesUpdated(const BitTorrent::Torrent *torrent
@ -72,12 +72,12 @@ private:
// No need to redeclare them here as slots. // No need to redeclare them here as slots.
void showMenu() override; void showMenu() override;
void applyFilter(int row) override; void applyFilter(int row) override;
void handleTorrentsLoaded(const QVector<BitTorrent::Torrent *> &torrents) override; void handleTorrentsLoaded(const QList<BitTorrent::Torrent *> &torrents) override;
void torrentAboutToBeDeleted(BitTorrent::Torrent *torrent) override; void torrentAboutToBeDeleted(BitTorrent::Torrent *torrent) override;
void onRemoveTrackerTriggered(); void onRemoveTrackerTriggered();
void addItems(const QString &trackerURL, const QVector<BitTorrent::TorrentID> &torrents); void addItems(const QString &trackerURL, const QList<BitTorrent::TorrentID> &torrents);
void removeItem(const QString &trackerURL, const BitTorrent::TorrentID &id); void removeItem(const QString &trackerURL, const BitTorrent::TorrentID &id);
QString trackerFromRow(int row) const; QString trackerFromRow(int row) const;
int rowFromTracker(const QString &tracker) const; int rowFromTracker(const QString &tracker) const;

2
src/gui/transferlistfilterswidget.cpp
View file

@ -176,7 +176,7 @@ void TransferListFiltersWidget::setDownloadTrackerFavicon(bool value)
m_trackersFilterWidget->setDownloadTrackerFavicon(value); m_trackersFilterWidget->setDownloadTrackerFavicon(value);
} }
void TransferListFiltersWidget::addTrackers(const BitTorrent::Torrent *torrent, const QVector<BitTorrent::TrackerEntry> &trackers) void TransferListFiltersWidget::addTrackers(const BitTorrent::Torrent *torrent, const QList<BitTorrent::TrackerEntry> &trackers)
{ {
m_trackersFilterWidget->addTrackers(torrent, trackers); m_trackersFilterWidget->addTrackers(torrent, trackers);
} }

2
src/gui/transferlistfilterswidget.h
View file

@ -56,7 +56,7 @@ public:
void setDownloadTrackerFavicon(bool value); void setDownloadTrackerFavicon(bool value);
public slots: public slots:
void addTrackers(const BitTorrent::Torrent *torrent, const QVector<BitTorrent::TrackerEntry> &trackers); void addTrackers(const BitTorrent::Torrent *torrent, const QList<BitTorrent::TrackerEntry> &trackers);
void removeTrackers(const BitTorrent::Torrent *torrent, const QStringList &trackers); void removeTrackers(const BitTorrent::Torrent *torrent, const QStringList &trackers);
void refreshTrackers(const BitTorrent::Torrent *torrent); void refreshTrackers(const BitTorrent::Torrent *torrent);
void trackerEntryStatusesUpdated(const BitTorrent::Torrent *torrent void trackerEntryStatusesUpdated(const BitTorrent::Torrent *torrent

4
src/gui/transferlistmodel.cpp
View file

@ -611,7 +611,7 @@ bool TransferListModel::setData(const QModelIndex &index, const QVariant &value,
return true; return true;
} }
void TransferListModel::addTorrents(const QVector<BitTorrent::Torrent *> &torrents) void TransferListModel::addTorrents(const QList<BitTorrent::Torrent *> &torrents)
{ {
qsizetype row = m_torrentList.size(); qsizetype row = m_torrentList.size();
const qsizetype total = row + torrents.size(); const qsizetype total = row + torrents.size();
@ -669,7 +669,7 @@ void TransferListModel::handleTorrentStatusUpdated(BitTorrent::Torrent *const to
emit dataChanged(index(row, 0), index(row, columnCount() - 1)); emit dataChanged(index(row, 0), index(row, columnCount() - 1));
} }
void TransferListModel::handleTorrentsUpdated(const QVector<BitTorrent::Torrent *> &torrents) void TransferListModel::handleTorrentsUpdated(const QList<BitTorrent::Torrent *> &torrents)
{ {
const int columns = (columnCount() - 1); const int columns = (columnCount() - 1);

4
src/gui/transferlistmodel.h
View file

@ -108,10 +108,10 @@ public:
BitTorrent::Torrent *torrentHandle(const QModelIndex &index) const; BitTorrent::Torrent *torrentHandle(const QModelIndex &index) const;
private slots: private slots:
void addTorrents(const QVector<BitTorrent::Torrent *> &torrents); void addTorrents(const QList<BitTorrent::Torrent *> &torrents);
void handleTorrentAboutToBeRemoved(BitTorrent::Torrent *torrent); void handleTorrentAboutToBeRemoved(BitTorrent::Torrent *torrent);
void handleTorrentStatusUpdated(BitTorrent::Torrent *torrent); void handleTorrentStatusUpdated(BitTorrent::Torrent *torrent);
void handleTorrentsUpdated(const QVector<BitTorrent::Torrent *> &torrents); void handleTorrentsUpdated(const QList<BitTorrent::Torrent *> &torrents);
private: private:
void configure(); void configure();

32
src/gui/transferlistwidget.cpp
View file

@ -35,12 +35,12 @@
#include <QDebug> #include <QDebug>
#include <QFileDialog> #include <QFileDialog>
#include <QHeaderView> #include <QHeaderView>
#include <QList>
#include <QMenu> #include <QMenu>
#include <QMessageBox> #include <QMessageBox>
#include <QRegularExpression> #include <QRegularExpression>
#include <QSet> #include <QSet>
#include <QShortcut> #include <QShortcut>
#include <QVector>
#include <QWheelEvent> #include <QWheelEvent>
#include "base/bittorrent/session.h" #include "base/bittorrent/session.h"
@ -76,9 +76,9 @@
namespace namespace
{ {
QVector<BitTorrent::TorrentID> extractIDs(const QVector<BitTorrent::Torrent *> &torrents) QList<BitTorrent::TorrentID> extractIDs(const QList<BitTorrent::Torrent *> &torrents)
{ {
QVector<BitTorrent::TorrentID> torrentIDs; QList<BitTorrent::TorrentID> torrentIDs;
torrentIDs.reserve(torrents.size()); torrentIDs.reserve(torrents.size());
for (const BitTorrent::Torrent *torrent : torrents) for (const BitTorrent::Torrent *torrent : torrents)
torrentIDs << torrent->id(); torrentIDs << torrent->id();
@ -113,7 +113,7 @@ namespace
#endif #endif
} }
void removeTorrents(const QVector<BitTorrent::Torrent *> &torrents, const bool isDeleteFileSelected) void removeTorrents(const QList<BitTorrent::Torrent *> &torrents, const bool isDeleteFileSelected)
{ {
auto *session = BitTorrent::Session::instance(); auto *session = BitTorrent::Session::instance();
const BitTorrent::TorrentRemoveOption removeOption = isDeleteFileSelected const BitTorrent::TorrentRemoveOption removeOption = isDeleteFileSelected
@ -323,22 +323,22 @@ void TransferListWidget::torrentDoubleClicked()
} }
} }
QVector<BitTorrent::Torrent *> TransferListWidget::getSelectedTorrents() const QList<BitTorrent::Torrent *> TransferListWidget::getSelectedTorrents() const
{ {
const QModelIndexList selectedRows = selectionModel()->selectedRows(); const QModelIndexList selectedRows = selectionModel()->selectedRows();
QVector<BitTorrent::Torrent *> torrents; QList<BitTorrent::Torrent *> torrents;
torrents.reserve(selectedRows.size()); torrents.reserve(selectedRows.size());
for (const QModelIndex &index : selectedRows) for (const QModelIndex &index : selectedRows)
torrents << m_listModel->torrentHandle(mapToSource(index)); torrents << m_listModel->torrentHandle(mapToSource(index));
return torrents; return torrents;
} }
QVector<BitTorrent::Torrent *> TransferListWidget::getVisibleTorrents() const QList<BitTorrent::Torrent *> TransferListWidget::getVisibleTorrents() const
{ {
const int visibleTorrentsCount = m_sortFilterModel->rowCount(); const int visibleTorrentsCount = m_sortFilterModel->rowCount();
QVector<BitTorrent::Torrent *> torrents; QList<BitTorrent::Torrent *> torrents;
torrents.reserve(visibleTorrentsCount); torrents.reserve(visibleTorrentsCount);
for (int i = 0; i < visibleTorrentsCount; ++i) for (int i = 0; i < visibleTorrentsCount; ++i)
torrents << m_listModel->torrentHandle(mapToSource(m_sortFilterModel->index(i, 0))); torrents << m_listModel->torrentHandle(mapToSource(m_sortFilterModel->index(i, 0)));
@ -347,7 +347,7 @@ QVector<BitTorrent::Torrent *> TransferListWidget::getVisibleTorrents() const
void TransferListWidget::setSelectedTorrentsLocation() void TransferListWidget::setSelectedTorrentsLocation()
{ {
const QVector<BitTorrent::Torrent *> torrents = getSelectedTorrents(); const QList<BitTorrent::Torrent *> torrents = getSelectedTorrents();
if (torrents.isEmpty()) if (torrents.isEmpty())
return; return;
@ -359,7 +359,7 @@ void TransferListWidget::setSelectedTorrentsLocation()
fileDialog->setOptions(QFileDialog::DontConfirmOverwrite | QFileDialog::ShowDirsOnly | QFileDialog::HideNameFilterDetails); fileDialog->setOptions(QFileDialog::DontConfirmOverwrite | QFileDialog::ShowDirsOnly | QFileDialog::HideNameFilterDetails);
connect(fileDialog, &QDialog::accepted, this, [this, fileDialog]() connect(fileDialog, &QDialog::accepted, this, [this, fileDialog]()
{ {
const QVector<BitTorrent::Torrent *> torrents = getSelectedTorrents(); const QList<BitTorrent::Torrent *> torrents = getSelectedTorrents();
if (torrents.isEmpty()) if (torrents.isEmpty())
return; return;
@ -432,7 +432,7 @@ void TransferListWidget::deleteSelectedTorrents(const bool deleteLocalFiles)
{ {
if (m_mainWindow->currentTabWidget() != this) return; if (m_mainWindow->currentTabWidget() != this) return;
const QVector<BitTorrent::Torrent *> torrents = getSelectedTorrents(); const QList<BitTorrent::Torrent *> torrents = getSelectedTorrents();
if (torrents.empty()) return; if (torrents.empty()) return;
if (Preferences::instance()->confirmTorrentDeletion()) if (Preferences::instance()->confirmTorrentDeletion())
@ -455,7 +455,7 @@ void TransferListWidget::deleteSelectedTorrents(const bool deleteLocalFiles)
void TransferListWidget::deleteVisibleTorrents() void TransferListWidget::deleteVisibleTorrents()
{ {
const QVector<BitTorrent::Torrent *> torrents = getVisibleTorrents(); const QList<BitTorrent::Torrent *> torrents = getVisibleTorrents();
if (torrents.empty()) return; if (torrents.empty()) return;
if (Preferences::instance()->confirmTorrentDeletion()) if (Preferences::instance()->confirmTorrentDeletion())
@ -624,7 +624,7 @@ void TransferListWidget::previewSelectedTorrents()
void TransferListWidget::setTorrentOptions() void TransferListWidget::setTorrentOptions()
{ {
const QVector<BitTorrent::Torrent *> selectedTorrents = getSelectedTorrents(); const QList<BitTorrent::Torrent *> selectedTorrents = getSelectedTorrents();
if (selectedTorrents.empty()) return; if (selectedTorrents.empty()) return;
auto *dialog = new TorrentOptionsDialog {this, selectedTorrents}; auto *dialog = new TorrentOptionsDialog {this, selectedTorrents};
@ -761,8 +761,8 @@ void TransferListWidget::askAddTagsForSelection()
void TransferListWidget::editTorrentTrackers() void TransferListWidget::editTorrentTrackers()
{ {
const QVector<BitTorrent::Torrent *> torrents = getSelectedTorrents(); const QList<BitTorrent::Torrent *> torrents = getSelectedTorrents();
QVector<BitTorrent::TrackerEntry> commonTrackers; QList<BitTorrent::TrackerEntry> commonTrackers;
if (!torrents.empty()) if (!torrents.empty())
{ {
@ -805,7 +805,7 @@ void TransferListWidget::exportTorrent()
fileDialog->setOptions(QFileDialog::ShowDirsOnly); fileDialog->setOptions(QFileDialog::ShowDirsOnly);
connect(fileDialog, &QFileDialog::fileSelected, this, [this](const QString &dir) connect(fileDialog, &QFileDialog::fileSelected, this, [this](const QString &dir)
{ {
const QVector<BitTorrent::Torrent *> torrents = getSelectedTorrents(); const QList<BitTorrent::Torrent *> torrents = getSelectedTorrents();
if (torrents.isEmpty()) if (torrents.isEmpty())
return; return;

4
src/gui/transferlistwidget.h
View file

@ -124,14 +124,14 @@ private:
QModelIndexList mapToSource(const QModelIndexList &indexes) const; QModelIndexList mapToSource(const QModelIndexList &indexes) const;
QModelIndex mapFromSource(const QModelIndex &index) const; QModelIndex mapFromSource(const QModelIndex &index) const;
bool loadSettings(); bool loadSettings();
QVector<BitTorrent::Torrent *> getSelectedTorrents() const; QList<BitTorrent::Torrent *> getSelectedTorrents() const;
void askAddTagsForSelection(); void askAddTagsForSelection();
void editTorrentTrackers(); void editTorrentTrackers();
void exportTorrent(); void exportTorrent();
void confirmRemoveAllTagsForSelection(); void confirmRemoveAllTagsForSelection();
TagSet askTagsForSelection(const QString &dialogTitle); TagSet askTagsForSelection(const QString &dialogTitle);
void applyToSelectedTorrents(const std::function<void (BitTorrent::Torrent *const)> &fn); void applyToSelectedTorrents(const std::function<void (BitTorrent::Torrent *const)> &fn);
QVector<BitTorrent::Torrent *> getVisibleTorrents() const; QList<BitTorrent::Torrent *> getVisibleTorrents() const;
int visibleColumnsCount() const; int visibleColumnsCount() const;
TransferListModel *m_listModel = nullptr; TransferListModel *m_listModel = nullptr;

4
src/webui/api/apicontroller.cpp
View file

@ -32,8 +32,8 @@
#include <QHash> #include <QHash>
#include <QJsonDocument> #include <QJsonDocument>
#include <QList>
#include <QMetaObject> #include <QMetaObject>
#include <QVector>
#include "apierror.h" #include "apierror.h"
@ -72,7 +72,7 @@ const DataMap &APIController::data() const
return m_data; return m_data;
} }
void APIController::requireParams(const QVector<QString> &requiredParams) const void APIController::requireParams(const QList<QString> &requiredParams) const
{ {
const bool hasAllRequiredParams = std::all_of(requiredParams.cbegin(), requiredParams.cend() const bool hasAllRequiredParams = std::all_of(requiredParams.cbegin(), requiredParams.cend()
, [this](const QString &requiredParam) , [this](const QString &requiredParam)

2
src/webui/api/apicontroller.h
View file

@ -60,7 +60,7 @@ public:
protected: protected:
const StringMap &params() const; const StringMap &params() const;
const DataMap &data() const; const DataMap &data() const;
void requireParams(const QVector<QString> &requiredParams) const; void requireParams(const QList<QString> &requiredParams) const;
void setResult(const QString &result); void setResult(const QString &result);
void setResult(const QJsonArray &result); void setResult(const QJsonArray &result);

2
src/webui/api/logcontroller.cpp
View file

@ -30,7 +30,7 @@
#include <QJsonArray> #include <QJsonArray>
#include <QJsonObject> #include <QJsonObject>
#include <QVector> #include <QList>
#include "base/global.h" #include "base/global.h"
#include "base/logger.h" #include "base/logger.h"

2
src/webui/api/rsscontroller.cpp
View file

@ -32,7 +32,7 @@
#include <QJsonDocument> #include <QJsonDocument>
#include <QJsonObject> #include <QJsonObject>
#include <QJsonValue> #include <QJsonValue>
#include <QVector> #include <QList>
#include "base/rss/rss_article.h" #include "base/rss/rss_article.h"
#include "base/rss/rss_autodownloader.h" #include "base/rss/rss_autodownloader.h"

2
src/webui/api/serialize/serialize_torrent.cpp
View file

@ -29,7 +29,7 @@
#include "serialize_torrent.h" #include "serialize_torrent.h"
#include <QDateTime> #include <QDateTime>
#include <QVector> #include <QList>
#include "base/bittorrent/infohash.h" #include "base/bittorrent/infohash.h"
#include "base/bittorrent/torrent.h" #include "base/bittorrent/torrent.h"

6
src/webui/api/synccontroller.cpp
View file

@ -732,7 +732,7 @@ void SyncController::torrentPeersAction()
QVariantMap data; QVariantMap data;
QVariantHash peers; QVariantHash peers;
const QVector<BitTorrent::PeerInfo> peersList = torrent->peers(); const QList<BitTorrent::PeerInfo> peersList = torrent->peers();
bool resolvePeerCountries = Preferences::instance()->resolvePeerCountries(); bool resolvePeerCountries = Preferences::instance()->resolvePeerCountries();
@ -912,7 +912,7 @@ void SyncController::onTorrentTagRemoved(BitTorrent::Torrent *torrent, [[maybe_u
m_updatedTorrents.insert(torrent->id()); m_updatedTorrents.insert(torrent->id());
} }
void SyncController::onTorrentsUpdated(const QVector<BitTorrent::Torrent *> &torrents) void SyncController::onTorrentsUpdated(const QList<BitTorrent::Torrent *> &torrents)
{ {
for (const BitTorrent::Torrent *torrent : torrents) for (const BitTorrent::Torrent *torrent : torrents)
m_updatedTorrents.insert(torrent->id()); m_updatedTorrents.insert(torrent->id());
@ -922,7 +922,7 @@ void SyncController::onTorrentTrackersChanged(BitTorrent::Torrent *torrent)
{ {
using namespace BitTorrent; using namespace BitTorrent;
const QVector<TrackerEntryStatus> trackers = torrent->trackers(); const QList<TrackerEntryStatus> trackers = torrent->trackers();
QSet<QString> currentTrackers; QSet<QString> currentTrackers;
currentTrackers.reserve(trackers.size()); currentTrackers.reserve(trackers.size());

2
src/webui/api/synccontroller.h
View file

@ -77,7 +77,7 @@ private:
void onTorrentSavingModeChanged(BitTorrent::Torrent *torrent); void onTorrentSavingModeChanged(BitTorrent::Torrent *torrent);
void onTorrentTagAdded(BitTorrent::Torrent *torrent, const Tag &tag); void onTorrentTagAdded(BitTorrent::Torrent *torrent, const Tag &tag);
void onTorrentTagRemoved(BitTorrent::Torrent *torrent, const Tag &tag); void onTorrentTagRemoved(BitTorrent::Torrent *torrent, const Tag &tag);
void onTorrentsUpdated(const QVector<BitTorrent::Torrent *> &torrents); void onTorrentsUpdated(const QList<BitTorrent::Torrent *> &torrents);
void onTorrentTrackersChanged(BitTorrent::Torrent *torrent); void onTorrentTrackersChanged(BitTorrent::Torrent *torrent);
qint64 m_freeDiskSpace = 0; qint64 m_freeDiskSpace = 0;

18
src/webui/api/torrentscontroller.cpp
View file

@ -242,9 +242,9 @@ namespace
return {dht, pex, lsd}; return {dht, pex, lsd};
} }
QVector<BitTorrent::TorrentID> toTorrentIDs(const QStringList &idStrings) QList<BitTorrent::TorrentID> toTorrentIDs(const QStringList &idStrings)
{ {
QVector<BitTorrent::TorrentID> idList; QList<BitTorrent::TorrentID> idList;
idList.reserve(idStrings.size()); idList.reserve(idStrings.size());
for (const QString &hash : idStrings) for (const QString &hash : idStrings)
idList << BitTorrent::TorrentID::fromString(hash); idList << BitTorrent::TorrentID::fromString(hash);
@ -576,7 +576,7 @@ void TorrentsController::filesAction()
throw APIError(APIErrorType::NotFound); throw APIError(APIErrorType::NotFound);
const int filesCount = torrent->filesCount(); const int filesCount = torrent->filesCount();
QVector<int> fileIndexes; QList<int> fileIndexes;
const auto idxIt = params().constFind(u"indexes"_s); const auto idxIt = params().constFind(u"indexes"_s);
if (idxIt != params().cend()) if (idxIt != params().cend())
{ {
@ -604,9 +604,9 @@ void TorrentsController::filesAction()
QJsonArray fileList; QJsonArray fileList;
if (torrent->hasMetadata()) if (torrent->hasMetadata())
{ {
const QVector<BitTorrent::DownloadPriority> priorities = torrent->filePriorities(); const QList<BitTorrent::DownloadPriority> priorities = torrent->filePriorities();
const QVector<qreal> fp = torrent->filesProgress(); const QList<qreal> fp = torrent->filesProgress();
const QVector<qreal> fileAvailability = torrent->availableFileFractions(); const QList<qreal> fileAvailability = torrent->availableFileFractions();
const BitTorrent::TorrentInfo info = torrent->info(); const BitTorrent::TorrentInfo info = torrent->info();
for (const int index : asConst(fileIndexes)) for (const int index : asConst(fileIndexes))
{ {
@ -648,7 +648,7 @@ void TorrentsController::pieceHashesAction()
QJsonArray pieceHashes; QJsonArray pieceHashes;
if (torrent->hasMetadata()) if (torrent->hasMetadata())
{ {
const QVector<QByteArray> hashes = torrent->info().pieceHashes(); const QList<QByteArray> hashes = torrent->info().pieceHashes();
for (const QByteArray &hash : hashes) for (const QByteArray &hash : hashes)
pieceHashes.append(QString::fromLatin1(hash.toHex())); pieceHashes.append(QString::fromLatin1(hash.toHex()));
} }
@ -889,7 +889,7 @@ void TorrentsController::addPeersAction()
const QStringList hashes = params()[u"hashes"_s].split(u'|'); const QStringList hashes = params()[u"hashes"_s].split(u'|');
const QStringList peers = params()[u"peers"_s].split(u'|'); const QStringList peers = params()[u"peers"_s].split(u'|');
QVector<BitTorrent::PeerAddress> peerList; QList<BitTorrent::PeerAddress> peerList;
peerList.reserve(peers.size()); peerList.reserve(peers.size());
for (const QString &peer : peers) for (const QString &peer : peers)
{ {
@ -956,7 +956,7 @@ void TorrentsController::filePrioAction()
throw APIError(APIErrorType::Conflict, tr("Torrent's metadata has not yet downloaded")); throw APIError(APIErrorType::Conflict, tr("Torrent's metadata has not yet downloaded"));
const int filesCount = torrent->filesCount(); const int filesCount = torrent->filesCount();
QVector<BitTorrent::DownloadPriority> priorities = torrent->filePriorities(); QList<BitTorrent::DownloadPriority> priorities = torrent->filePriorities();
bool priorityChanged = false; bool priorityChanged = false;
for (const QString &fileID : params()[u"id"_s].split(u'|')) for (const QString &fileID : params()[u"id"_s].split(u'|'))
{ {

2
src/webui/api/transfercontroller.cpp
View file

@ -29,7 +29,7 @@
#include "transfercontroller.h" #include "transfercontroller.h"
#include <QJsonObject> #include <QJsonObject>
#include <QVector> #include <QList>
#include "base/bittorrent/peeraddress.h" #include "base/bittorrent/peeraddress.h"
#include "base/bittorrent/peerinfo.h" #include "base/bittorrent/peerinfo.h"

8
src/webui/webapplication.h
View file

@ -36,12 +36,12 @@
#include <QElapsedTimer> #include <QElapsedTimer>
#include <QHash> #include <QHash>
#include <QHostAddress> #include <QHostAddress>
#include <QList>
#include <QMap> #include <QMap>
#include <QObject> #include <QObject>
#include <QRegularExpression> #include <QRegularExpression>
#include <QSet> #include <QSet>
#include <QTranslator> #include <QTranslator>
#include <QVector>
#include "base/applicationcomponent.h" #include "base/applicationcomponent.h"
#include "base/global.h" #include "base/global.h"
@ -234,7 +234,7 @@ private:
AuthController *m_authController = nullptr; AuthController *m_authController = nullptr;
bool m_isLocalAuthEnabled = false; bool m_isLocalAuthEnabled = false;
bool m_isAuthSubnetWhitelistEnabled = false; bool m_isAuthSubnetWhitelistEnabled = false;
QVector<Utils::Net::Subnet> m_authSubnetWhitelist; QList<Utils::Net::Subnet> m_authSubnetWhitelist;
int m_sessionTimeout = 0; int m_sessionTimeout = 0;
QString m_sessionCookieName; QString m_sessionCookieName;
@ -247,10 +247,10 @@ private:
// Reverse proxy // Reverse proxy
bool m_isReverseProxySupportEnabled = false; bool m_isReverseProxySupportEnabled = false;
QVector<Utils::Net::Subnet> m_trustedReverseProxyList; QList<Utils::Net::Subnet> m_trustedReverseProxyList;
QHostAddress m_clientAddress; QHostAddress m_clientAddress;
QVector<Http::Header> m_prebuiltHeaders; QList<Http::Header> m_prebuiltHeaders;
Utils::Thread::UniquePtr m_workerThread; Utils::Thread::UniquePtr m_workerThread;
FreeDiskSpaceChecker *m_freeDiskSpaceChecker = nullptr; FreeDiskSpaceChecker *m_freeDiskSpaceChecker = nullptr;