src/base/torrentfilter.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2014  Vladimir Golovnev <glassez@yandex.ru>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  *
  19  * In addition, as a special exception, the copyright holders give permission to
  20  * link this program with the OpenSSL project's "OpenSSL" library (or with
  21  * modified versions of it that use the same license as the "OpenSSL" library),
  22  * and distribute the linked executables. You must obey the GNU General Public
  23  * License in all respects for all of the code used other than "OpenSSL".  If you
  24  * modify file(s), you may extend this exception to your version of the file(s),
  25  * but you are not obligated to do so. If you do not wish to do so, delete this
  26  * exception statement from your version.
  27  */
  28
  29 #include "torrentfilter.h"
  30
  31 #include "bittorrent/infohash.h"
  32 #include "bittorrent/torrent.h"
  33
  34 const std::optional<QString> TorrentFilter::AnyCategory;
  35 const std::optional<TorrentIDSet> TorrentFilter::AnyID;
  36 const std::optional<QString> TorrentFilter::AnyTag;
  37
  38 const TorrentFilter TorrentFilter::DownloadingTorrent(TorrentFilter::Downloading);
  39 const TorrentFilter TorrentFilter::SeedingTorrent(TorrentFilter::Seeding);
  40 const TorrentFilter TorrentFilter::CompletedTorrent(TorrentFilter::Completed);
  41 const TorrentFilter TorrentFilter::PausedTorrent(TorrentFilter::Paused);
  42 const TorrentFilter TorrentFilter::ResumedTorrent(TorrentFilter::Resumed);
  43 const TorrentFilter TorrentFilter::ActiveTorrent(TorrentFilter::Active);
  44 const TorrentFilter TorrentFilter::InactiveTorrent(TorrentFilter::Inactive);
  45 const TorrentFilter TorrentFilter::StalledTorrent(TorrentFilter::Stalled);
  46 const TorrentFilter TorrentFilter::StalledUploadingTorrent(TorrentFilter::StalledUploading);
  47 const TorrentFilter TorrentFilter::StalledDownloadingTorrent(TorrentFilter::StalledDownloading);
  48 const TorrentFilter TorrentFilter::CheckingTorrent(TorrentFilter::Checking);
  49 const TorrentFilter TorrentFilter::ErroredTorrent(TorrentFilter::Errored);
  50
  51 using BitTorrent::Torrent;
  52
  53 TorrentFilter::TorrentFilter(const Type type, const std::optional<TorrentIDSet> &idSet
  54                              , const std::optional<QString> &category, const std::optional<QString> &tag)
  55     : m_type(type)
  56     , m_category(category)
  57     , m_tag(tag)
  58     , m_idSet(idSet)
  59 {
  60 }
  61
  62 TorrentFilter::TorrentFilter(const QString &filter, const std::optional<TorrentIDSet> &idSet
  63                              , const std::optional<QString> &category, const std::optional<QString> &tag)
  64     : m_type(All)
  65     , m_category(category)
  66     , m_tag(tag)
  67     , m_idSet(idSet)
  68 {
  69     setTypeByName(filter);
  70 }
  71
  72 bool TorrentFilter::setType(Type type)
  73 {
  74     if (m_type != type)
  75     {
  76         m_type = type;
  77         return true;
  78     }
  79
  80     return false;
  81 }
  82
  83 bool TorrentFilter::setTypeByName(const QString &filter)
  84 {
  85     Type type = All;
  86
  87     if (filter == u"downloading")
  88         type = Downloading;
  89     else if (filter == u"seeding")
  90         type = Seeding;
  91     else if (filter == u"completed")
  92         type = Completed;
  93     else if (filter == u"paused")
  94         type = Paused;
  95     else if (filter == u"resumed")
  96         type = Resumed;
  97     else if (filter == u"active")
  98         type = Active;
  99     else if (filter == u"inactive")
 100         type = Inactive;
 101     else if (filter == u"stalled")
 102         type = Stalled;
 103     else if (filter == u"stalled_uploading")
 104         type = StalledUploading;
 105     else if (filter == u"stalled_downloading")
 106         type = StalledDownloading;
 107     else if (filter == u"checking")
 108         type = Checking;
 109     else if (filter == u"errored")
 110         type = Errored;
 111
 112     return setType(type);
 113 }
 114
 115 bool TorrentFilter::setTorrentIDSet(const std::optional<TorrentIDSet> &idSet)
 116 {
 117     if (m_idSet != idSet)
 118     {
 119         m_idSet = idSet;
 120         return true;
 121     }
 122
 123     return false;
 124 }
 125
 126 bool TorrentFilter::setCategory(const std::optional<QString> &category)
 127 {
 128     if (m_category != category)
 129     {
 130         m_category = category;
 131         return true;
 132     }
 133
 134     return false;
 135 }
 136
 137 bool TorrentFilter::setTag(const std::optional<QString> &tag)
 138 {
 139     if (m_tag != tag)
 140     {
 141         m_tag = tag;
 142         return true;
 143     }
 144
 145     return false;
 146 }
 147
 148 bool TorrentFilter::match(const Torrent *const torrent) const
 149 {
 150     if (!torrent) return false;
 151
 152     return (matchState(torrent) && matchHash(torrent) && matchCategory(torrent) && matchTag(torrent));
 153 }
 154
 155 bool TorrentFilter::matchState(const BitTorrent::Torrent *const torrent) const
 156 {
 157     switch (m_type)
 158     {
 159     case All:
 160         return true;
 161     case Downloading:
 162         return torrent->isDownloading();
 163     case Seeding:
 164         return torrent->isUploading();
 165     case Completed:
 166         return torrent->isCompleted();
 167     case Paused:
 168         return torrent->isPaused();
 169     case Resumed:
 170         return torrent->isResumed();
 171     case Active:
 172         return torrent->isActive();
 173     case Inactive:
 174         return torrent->isInactive();
 175     case Stalled:
 176         return (torrent->state() ==  BitTorrent::TorrentState::StalledUploading)
 177                 || (torrent->state() ==  BitTorrent::TorrentState::StalledDownloading);
 178     case StalledUploading:
 179         return torrent->state() ==  BitTorrent::TorrentState::StalledUploading;
 180     case StalledDownloading:
 181         return torrent->state() ==  BitTorrent::TorrentState::StalledDownloading;
 182     case Checking:
 183         return (torrent->state() == BitTorrent::TorrentState::CheckingUploading)
 184                 || (torrent->state() == BitTorrent::TorrentState::CheckingDownloading)
 185                 || (torrent->state() == BitTorrent::TorrentState::CheckingResumeData);
 186     case Errored:
 187         return torrent->isErrored();
 188     default: // All
 189         return true;
 190     }
 191 }
 192
 193 bool TorrentFilter::matchHash(const BitTorrent::Torrent *const torrent) const
 194 {
 195     if (!m_idSet)
 196         return true;
 197
 198     return m_idSet->contains(torrent->id());
 199 }
 200
 201 bool TorrentFilter::matchCategory(const BitTorrent::Torrent *const torrent) const
 202 {
 203     if (!m_category)
 204         return true;
 205
 206     return (torrent->belongsToCategory(*m_category));
 207 }
 208
 209 bool TorrentFilter::matchTag(const BitTorrent::Torrent *const torrent) const
 210 {
 211     if (!m_tag)
 212         return true;
 213
 214     // Empty tag is a special value to indicate we're filtering for untagged torrents.
 215     if (m_tag->isEmpty())
 216         return torrent->tags().isEmpty();
 217
 218     return torrent->hasTag(*m_tag);
 219 }