Implemented share limit by seeding time

src/base/bittorrent/torrenthandle.cpp

@@ -81,6 +81,7 @@ AddTorrentData::AddTorrentData()
     , addForced(false)
     , addPaused(false)
     , ratioLimit(TorrentHandle::USE_GLOBAL_RATIO)
+    , seedingTimeLimit(TorrentHandle::USE_GLOBAL_SEEDING_TIME)
 {
 }
 
@@ -102,7 +103,8 @@ AddTorrentData::AddTorrentData(const AddTorrentParams &params)
                 ? Session::instance()->isAddTorrentPaused()
                 : params.addPaused == TriStateBool::True)
     , filePriorities(params.filePriorities)
-    , ratioLimit(params.ignoreShareRatio ? TorrentHandle::NO_RATIO_LIMIT : TorrentHandle::USE_GLOBAL_RATIO)
+    , ratioLimit(params.ignoreShareLimits ? TorrentHandle::NO_RATIO_LIMIT : TorrentHandle::USE_GLOBAL_RATIO)
+    , seedingTimeLimit(params.ignoreShareLimits ? TorrentHandle::NO_SEEDING_TIME_LIMIT : TorrentHandle::USE_GLOBAL_SEEDING_TIME)
 {
 }
 
@@ -169,7 +171,11 @@ TorrentState::operator int() const
 const qreal TorrentHandle::USE_GLOBAL_RATIO = -2.;
 const qreal TorrentHandle::NO_RATIO_LIMIT = -1.;
 
+const int TorrentHandle::USE_GLOBAL_SEEDING_TIME = -2;
+const int TorrentHandle::NO_SEEDING_TIME_LIMIT = -1;
+
 const qreal TorrentHandle::MAX_RATIO = 9999.;
+const int TorrentHandle::MAX_SEEDING_TIME = 525600;
 
 // The new libtorrent::create_torrent constructor appeared after 1.0.11 in RC_1_0
 // and after 1.1.1 in RC_1_1. Since it fixed an ABI incompatibility with previous versions
@@ -209,6 +215,7 @@ TorrentHandle::TorrentHandle(Session *session, const libtorrent::torrent_handle
     , m_category(data.category)
     , m_hasSeedStatus(data.hasSeedStatus)
     , m_ratioLimit(data.ratioLimit)
+    , m_seedingTimeLimit(data.seedingTimeLimit)
     , m_tempPathDisabled(data.disableTempPath)
     , m_hasMissingFiles(false)
     , m_hasRootFolder(data.hasRootFolder)
@@ -581,6 +588,11 @@ qreal TorrentHandle::ratioLimit() const
     return m_ratioLimit;
 }
 
+int TorrentHandle::seedingTimeLimit() const
+{
+    return m_seedingTimeLimit;
+}
+
 QString TorrentHandle::filePath(int index) const
 {
     return m_torrentInfo.filePath(index);
@@ -907,24 +919,38 @@ qulonglong TorrentHandle::eta() const
 {
     if (isPaused()) return MAX_ETA;
 
-    const SpeedSampleAvg speed_average = m_speedMonitor.average();
+    const SpeedSampleAvg speedAverage = m_speedMonitor.average();
 
     if (isSeed()) {
-        if (speed_average.upload == 0) return MAX_ETA;
+        qreal maxRatioValue = maxRatio();
+        int maxSeedingTimeValue = maxSeedingTime();
+        if ((maxRatioValue < 0) && (maxSeedingTimeValue < 0)) return MAX_ETA;
 
-        qreal max_ratio = maxRatio();
-        if (max_ratio < 0) return MAX_ETA;
+        qlonglong ratioEta = MAX_ETA;
 
-        qlonglong realDL = totalDownload();
-        if (realDL <= 0)
-            realDL = wantedSize();
+        if ((speedAverage.upload > 0) && (maxRatioValue >= 0)) {
 
-        return ((realDL * max_ratio) - totalUpload()) / speed_average.upload;
+            qlonglong realDL = totalDownload();
+            if (realDL <= 0)
+                realDL = wantedSize();
+
+            ratioEta = ((realDL * maxRatioValue) - totalUpload()) / speedAverage.upload;
+        }
+
+        qlonglong seedingTimeEta = MAX_ETA;
+
+        if (maxSeedingTimeValue >= 0) {
+            seedingTimeEta = (maxSeedingTimeValue * 60) - seedingTime();
+            if (seedingTimeEta < 0)
+                seedingTimeEta = 0;
+        }
+
+        return qMin(ratioEta, seedingTimeEta);
     }
 
-    if (!speed_average.download) return MAX_ETA;
+    if (!speedAverage.download) return MAX_ETA;
 
-    return (wantedSize() - completedSize()) / speed_average.download;
+    return (wantedSize() - completedSize()) / speedAverage.download;
 }
 
 QVector<qreal> TorrentHandle::filesProgress() const
@@ -1105,6 +1131,23 @@ qreal TorrentHandle::maxRatio(bool *usesGlobalRatio) const
     return ratioLimit;
 }
 
+int TorrentHandle::maxSeedingTime(bool *usesGlobalSeedingTime) const
+{
+    int seedingTimeLimit = m_seedingTimeLimit;
+
+    if (seedingTimeLimit == USE_GLOBAL_SEEDING_TIME) {
+        seedingTimeLimit = m_session->globalMaxSeedingMinutes();
+        if (usesGlobalSeedingTime)
+            *usesGlobalSeedingTime = true;
+    }
+    else {
+        if (usesGlobalSeedingTime)
+            *usesGlobalSeedingTime = false;
+    }
+
+    return seedingTimeLimit;
+}
+
 qreal TorrentHandle::realRatio() const
 {
     boost::int64_t upload = m_nativeStatus.all_time_upload;
@@ -1572,6 +1615,7 @@ void TorrentHandle::handleSaveResumeDataAlert(libtorrent::save_resume_data_alert
     }
     resumeData["qBt-savePath"] = m_useAutoTMM ? "" : Profile::instance().toPortablePath(m_savePath).toStdString();
     resumeData["qBt-ratioLimit"] = QString::number(m_ratioLimit).toStdString();
+    resumeData["qBt-seedingTimeLimit"] = QString::number(m_seedingTimeLimit).toStdString();
     resumeData["qBt-category"] = m_category.toStdString();
     resumeData["qBt-name"] = m_name.toStdString();
     resumeData["qBt-seedStatus"] = m_hasSeedStatus;
@@ -1878,7 +1922,21 @@ void TorrentHandle::setRatioLimit(qreal limit)
     if (m_ratioLimit != limit) {
         m_ratioLimit = limit;
         m_needSaveResumeData = true;
-        m_session->handleTorrentRatioLimitChanged(this);
+        m_session->handleTorrentShareLimitChanged(this);
+    }
+}
+
+void TorrentHandle::setSeedingTimeLimit(int limit)
+{
+    if (limit < USE_GLOBAL_SEEDING_TIME)
+        limit = NO_SEEDING_TIME_LIMIT;
+    else if (limit > MAX_SEEDING_TIME)
+        limit = MAX_SEEDING_TIME;
+
+    if (m_seedingTimeLimit != limit) {
+        m_seedingTimeLimit = limit;
+        m_needSaveResumeData = true;
+        m_session->handleTorrentShareLimitChanged(this);
     }
 }